Vn1c0rn的逆向之旅

Study

1、 ida

  • shift f12---跳转string

  • ctrl x------交叉引用

  • shift e-----数据导出

  • a-----------转化为字符串数组

  • \------------去除灰色的变量解释

  • /------------添加注释

  • N-----------重命名

  • ctrl z------返回上一步, 撤回原行为

  • Y-----------重组数组(更改变量类型)

  • Alt b -------搜索bytes string

  • *(shift+8)------------构建数组(记得取消dup格式)

  • u-------------取消定义

  • _-------------把数值转换成无字符型

2、凯撒密码

可带入数值判断偏移量, 解密(注意大小写的条件可能不同)

3、RSA

ctf工具中公钥分析的应用, 需含begin end

4、x64dbg

按如图所示找到程序入口点(OEP)

选中(OEP)后按 shift d-------调用字符串界面

5、汇编代码转换成二进制可执行文件

linux下gcc安装

sudo apt install gcc

gcc -o name(可执行文件名) name.s(汇编代码)

6、打包

(1)upx使用

upx -v //查看command

upx --help //查看detail

(2)pyinstxtractor.py使用

用于脱pyinstaller

python3 pyinstxtractor.py path/file_name

脱壳后文件将于当前路径下生成

pyc文件转py

1、安装.pyc转.py所使用的库uncompyle6, 这里用了清华源并且指定使用了3.9.0版本库

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple uncompyle6==3.9.0

找到测试脚本.pyc所在的文件夹, cd 到此路径下, 并输入以下打包命令：

uncompyle6 -o 测试脚本.py 测试脚本.pyc

注意：uncompyle6针对的是3.8及以下的文件, 对高版本不适用

解决方案：可以找到uncompyle6识别版本的位置(uncompyle6报错路径)手动补上新版本号。

2、pycdc的使用

pycdc -o 测试脚本.py 测试脚本.pyc

7、加密函数

搜索一下(CryptCreateHash)是哈希算法的意思, 且0x8004表示sha1方法

这些粉红色的东东是Windows API

8、ida换编码

类似这种输出一个&byte_的, 有可能是因为有中文。

Option---general---strings---Default 8-bit由UTF-8换成另一个, 重启ida, 注意load exsite, id64存在编码方式不变。

尝试(1)不重启, 按f5.

(2)选中对应位置(注意带上‘0’)按a, 此时才能把中文带到伪代码中, 不加‘0’可能带不到伪代码中。

有的中文换编码后也没发现, 找到对应位置选中, 右键即可看到内容, 如图

9、花指令---jmp

选中此句, 点u

找到多出的语句, 此题为e9那句

直接把e9那句nop掉, 再按c转换成c代码

最后在main函数前面选中点p重新定义成函数

定义后结果

之后就可以反编译啦

时隔很长时间, 终于看懂了这个含义是什么, 打算补一下。

jz loc_117A+1,代表跳转到117A的第二个字节的位置, 跳过了第一个字节jmp(E9), 而ida会识别出来e9并于后面的机械码配对, 导致反编译错误。

10、dup命令

8 dup(0), 分配一段空间, 由8个0组成

故数组的后8个元素均为0, 而且末尾不存在8这个元素。

11、ida中元素转换为c语言数组常见错误

在clion中用h后缀表示的十六进制会报错, 更不能加上单引号使其强行正确, 应转化为0x前缀格式

字符型：先全选R键转换, 再复制粘贴；

整型：shift e提取, 再复制 (还有一个好处就是, 无需全选, 只需选中对应行, shift e可以提取该数组的所有值)

12、逆向中py脚本的编写

(1)字符串:

一维:a=' '

二维:b=[” “,” “]

(2)将字符转换为ASCLL码值 ord()

将ASCLL码值转变为字符 chr()

(3)py中整除符号：//

(4)print()会自动换行, 不换行需加上print('',end=' ')

13、ida识别错误转换问题

很明显是数组指针类型的v3, 故把__int64改成char *

后面的v3[i%3]+2*(i/3)也将改变成二维数组的类型

14、

(1)迷宫：

找到迷宫(二维数组看成一个迷宫, 三维数组看成多个迷宫)(自定义数组根据题目含义分析)

(1)直接convert---convert string----复制该十六进制数据, 在ida对话框中输出, 即可得到字符

(2)先按u取消定义, 后将其改为Byte型, 根据需要改变类型Byte、word、dword

再按*重组数组, 一般可以知道迷宫的行数或者列数, 估计另一个, 相乘得到数组大小。

再convert to Byte或word dword

附上迷宫脚本

def solve_maze(mp):
    # delta = [y,x,step]
    delta = [
        [0, -1, "a"], [0, 1, "d"], [-1, 0, "w"],
        [1, 0, "s"], [5, 0, "x"], [-5, 0, "y"]  # 操作数需要改
    ]
    path = ""
    N, M = 25, 5  # 长和宽需要改
    st = mp.index("s")  # 需要改 起始位置
    ed = mp.index("#")  # 终点位置
    ID = lambda x, y: x * M + y
    vis = [[False] * M for _ in range(N)]

    def dfs(x, y, cPath=""):
        nonlocal path
        if x < 0 or x >= N or y < 0 or y >= M or vis[x][y] or mp[ID(x, y)] == "*":  # 不可以走的路径
            return False
        if ID(x, y) == ed:
            path = cPath
            return True
        vis[x][y] = True
        for i in range(6):  # 对应delta有几个操作数
            fl = dfs(x + delta[i][0], y + delta[i][1], cPath + delta[i][2])
            if fl:
                vis[x][y] = False
                return True
        vis[x][y] = False
        return False

    dfs(st // M, st % M)
    return path


def main():
    mp = "**************.****.**s..*..******.****.***********..***..**..#*..***..***.********************.**..*******..**...*..*.*.**.*"  # 迷宫的数据
    path = solve_maze(mp)
    print(path)


if __name__ == "__main__":
    main()

(2)进阶迷宫:(如果发现地图的路线有多种, 第一种是想想是不是三维迷宫(移动键有6个), 第二种便有可能是此情况, 也可根据代码分析, 虽然有时候我看不出来, 哈哈)

遇到障碍物停止, 跑出地图程序结束。

15、linux文件远程调试

Debugger---process options

Application 路径加文件名(linux虚拟机)(可以只在这行加文件名, 让linux自动检测, 其他行不写任何东西)

Input file 路径加文件名(Linux虚拟机)

Directory 路径(Linux虚拟机)

Hostname 虚拟机ip

升高文件权限 chmod +x 文件名

例如：chmod +x rainbow

16、混淆

调试！！！

让程序跑起来, 之后输入内容, 在内容位置下断点(下断点后按ese返回), 调用该内容时便会停止, 分析该处对输入内容的加密！

17、z3的使用

API文档: https://z3prover.github.io/api/html/namespacez3py.html
第一步 创建变量

import z3
x = [z3.Int(f'x_{i}') for i in range(10)]
y = [z3.BitVec(f'y_{i}', 8) for i in range(10)]

第二步 创建求解器

solver = z3.Solver()

第三步 添加约束

solver.add()

第四步 求解方程

if solver.check() == z3.sat:
    print(solver.model())
else:
    print("该方程无解")

如果想按自定义顺序输出, 可以采取下面方法

m=solver.model() 
print(m[x])
print(m[y])

注意其中的m[x]与m[y]不是一个数字类型,而是一个字符串形式的数据,不能直接进行加减运算,可使用m[x].as_long()进行加减计算,转换成字符串也要chr(m[x].as_long())

注意事项:如果约束中出现位移符号,由于创建变量并非为int型,而是z3库的ArithRef类型,不能进行位移,可采取以下方法:

一:等价的方法,左移x位表示乘以2的x次方_

二：位向量转换为字符串

result1 = "".join(chr(m.evaluate(each).as_long()) for each in flag)
result2 = "".join(chr(m.evaluat(flag[i]).as_long()) for i in range(lenth))
print(result)


//最好不要用下面的形式,用evaluate()最好.
for i in flag:
    print(chr(m[i].as_long()),end='')
//或者下面形式
print(''.join(chr(m[flag[i]].as_long())for i in range(len(flag)))

这个8代表设置有8位,这种方法也可以快速设置变量,8位设置后可以对其再次进行约束

两个约束均可, 用其一即可。

哎,对于python的运用,还得多练。

更多用法可参考z3使用

z3有Or,And等函数,S.add(constraint1 or constraint2)是错误的

If(condition, true_case, false_case)

错误示例:
from z3 import *

x = Int('x')
y = Int('y')

# 这种方式是错误的, 因为它是在运行时评估的, 而不是构建符号表达式
if x > y:
    result = x
else:
    result = y

# 创建求解器并添加约束
solver = Solver()
solver.add(x == 5, y == 3)

if solver.check() == sat:
    model = solver.model()
    print(f"x = {model[x]}, y = {model[y]}, result = {model.evaluate(result)}")
else:
    print("不可满足")

正确用法:
from z3 import *

# 创建整数变量
x = Int('x')
y = Int('y')

# 使用 Z3 的 If 函数构建条件表达式
result = If(x > y, x, y)

# 创建求解器并添加约束
solver = Solver()
solver.add(x == 5, y == 3)

if solver.check() == sat:
    model = solver.model()
    print(f"x = {model[x]}, y = {model[y]}, result = {model.evaluate(result)}")
else:
    print("不可满足")

18、D810插件使用

shift+ctrl+D-----启动D810

启动后选择对应的混淆, 这里是ollvm混淆, 故选择此项, 点Start, 之后就可以欢快的按F5啦。

19、__gmpz_init_set_str函数

注意最后一个参数, base

21、base64类型思路

换表, 再正常不过, 当直接查看base_table时, 发现是原表, 我们不能知道它有没有换表, 在哪个函数里换表。这时就用到交叉引用啦, 查看一下, 除base64加密函数的另一个调用base_table的函数应该就是换表函数。

在这里就是O_OLookAtYou这个函数啦。

22、ida显示栈指针

23、idapython在脱花上的运用

调用pyscript

(1)file->script file(Alt F7) "先编写好脚本, 再调用"

(2)file->sript commend(Shift F2) "于ida中编写脚本"

常用ida的python函数 参考http://mtw.so/61YmOa

example

该代码便将所有的EB FF中的EB给nop掉了, 至于为什么这么做, 请看：

24、汇编指令

rol 左移, 最高位(最左面)补到最低位(最右面)

shr 右移 最右边的直接消失, 最左边补0

25、对于int型的返回给char型, char只读取最低八位

26、change byte的另一种用法(除去花外)

程序对密文encode, 输出为flag, 而程序只改动几个字符并没有全部改动, 目标：“改变encode的字符数”

汇编代码处, 选中数据区,右键->patching->change byte

之后修改成应该的数值就行了。

27、2月26日

1)siglongjmp, sigsetjmp

参考文献：https://blog.csdn.net/m0_61243666/article/details/131386182

2)signal函数

参考文献：https://blog.csdn.net/weixin_45556441/article/details/116279144

signal函数如果出现时很有可能出现了linux异常处理, 需动调观察哪里出现了异常处理, 异常处理后调用函数的作用。

3)ida中变量交叉引用出的函数是按顺序执行的。

28、2月27日

1)tea算法一般会将数据以四个字节的形式加密。一般表示为v1=*flag, v2=*(flag+4)

29、2月28日

1)流密码RC4
魔改注意点:轮数由256改为128;Data[k]=Data[k] ^ s[t]改为Data[k]=Data[k] ^ k ^ s[t]

/*初始化函数*/
void rc4_init(unsigned char *s, unsigned char *key, unsigned long Len) {
    int i = 0, j = 0;
    char k[256] = {0};
    unsigned char tmp = 0;
    for (i = 0; i < 256; i++) {
        s[i] = i;
        k[i] = key[i % Len];
    }
    for (i = 0; i < 256; i++) {
        j = (j + s[i] + k[i]) % 256;
        tmp = s[i];
        s[i] = s[j]; // 交换s[i]和s[j]
        s[j] = tmp;
    }
}

/*加解密*/
void rc4_crypt(unsigned char *s, unsigned char *Data, unsigned long Len) {
    int i = 0, j = 0, t = 0;
    unsigned long k = 0;
    unsigned char tmp;
    for (k = 0; k < Len; k++) {
        i = (i + 1) % 256;
        j = (j + s[i]) % 256;
        tmp = s[i];
        s[i] = s[j]; // 交换s[x]和s[y]
        s[j] = tmp;
        t = (s[i] + s[j]) % 256;
        Data[k] ^= s[t];
    }
}

解密2 :python解密

form Crypto.Cipher  import ARC4     # Cipher表示对称密码

rc4  = ARC4.new(b  ' ' )            # 'key'
flag  = rc4.decrypt(bytes.fromhex(  ' ' )     # 'convert->hexstring'

解密3 ：自吐(ida脚本编写)

from idaapi import *

v  = bytes.fromhex(  ' ' )
#第一个参数是 输入数据的内存地址
#第二个参数是 已经被加密后的数据
patch_bytes( 0x0 , v)
#py小知识:byte、string、元组不能原地修改,list可以

注意运行脚本后可能密文中可能又byte为0, 会影响strlen的判断, 此时就可以用7)的方法修改寄存器的值来解决了

2)ida如何将数据变为无符号型选中后右键->invert sign(快速识别常量)或者选中后按下划线

3)F4运行到光标位置

4)安装python密码库 pip install pycryptodome

5)RAX寄存器存取返回值, 例如strlen(flag)的值将存在RAX中

6)自动填充ida库中函数, 新建系统环境变量, 将ida目录中的python的路径设为变量值

7)在ida动态调试时可以修改寄存器的值：在general registers中选中寄存器右键->Modify value

30、2月29日

1)如果数据类型为dword, >>31与%256是一个性质；如果为word型, >>15与%256是一个性质。(以此就可以贴近上述的rc4代码)。

2)rc4魔改方式1, 将最后的异或操作改为+, -, *, /, 这样自吐与python解法就行不通了。

31、3月1日

1)<stdint.h>库, 含有uint16_t,uint32_t等类型。

2)加密算法一般只改某些特征值, 不会改变加密逻辑(因为可能玩逆向的害怕自己改了加密, 不知道怎么解密了), 所以识别加密算法尤为重要。

3)TEA算法(ida识为什么类型int or uint,再解密时便使用什么类型,如果int型密文报错便(int)强转一下)

#include 

void encrypt (uint32_t* v, uint32_t* k) {
    uint32_t v0=v[0], v1=v[1], sum=0, i;               /* set up */
    uint32_t delta=0x9e3779b9;                         /* a key schedule constant */
    uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3];       /* cache key */
    for (i=0; i < 32; i++) {                           /* basic cycle start */
        sum += delta;
        v0 += ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
        v1 += ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);  
    }                                                  /* end cycle */
    v[0]=v0; v[1]=v1;
}

void decrypt (uint32_t* v, uint32_t* k) {
    uint32_t v0=v[0], v1=v[1], sum=0xC6EF3720, i;      /* set up */
    uint32_t delta=0x9e3779b9;                         /* a key schedule constant */
    uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3];       /* cache key */
    for (i=0; i<32; i++) {                             /* basic cycle start */
        v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
        v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
        sum -= delta;
    }                                                  /* end cycle */
    v[0]=v0; v[1]=v1;
}

由delta=0x9e3779b9识别, 这个数据也很有可能被魔改

XTEA

#include 

/* take 64 bits of data in v[0] and v[1] and 128 bits of key[0] - key[3] */

void encipher(unsigned     int num_rounds, uint32_t v[2], uint32_t     const key[4]) {
    unsigned     int i;
    uint32_t v0=v[0], v1=v[1], sum=0, delta=0x9E3779B9;
    for (i=0; i < num_rounds; i++) {
        v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
        sum += delta;
        v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3]);
    }
    v[0]=v0; v[1]=v1;
}

void decipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) {
    unsigned int i;
    uint32_t v0=v[0], v1=v[1], delta=0x9E3779B9, sum=delta*num_rounds;
    for (i=0; i < num_rounds; i++) {
        v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3]);
        sum -= delta;
        v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
    }
    v[0]=v0; v[1]=v1;
}

由sum的位置确定, 其中detal的值也很有可能被魔改。

XXTEA

  #define DELTA 0x9e3779b9
  #define MX ((z>>5^y<<2) + (y>>3^z<<4) ^ (sum^y) + (k[p&3^e]^z)) 
 
  long btea(long* v, long n, long* k) {
    unsigned long z=v[n-1], y=v[0], sum=0, e;
    long p, q ;
    if (n > 1) {          /* Coding Part */
      q = 6 + 52/n;
      while (q-- > 0) {
        sum += DELTA;
        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;
      }
      return 0 ; 
    } else if (n < -1) {  /* Decoding Part */
      n = -n;
      q = 6 + 52/n;
      sum = q*DELTA ;
      while (sum != 0) {
        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 -= DELTA;
      }
      return 0;
    }
    return 1;
  }

一般来说,识别可以通过,delta 以及round = 6 + 52/n、(sum >> 2) & 3这种特殊的运算来判断。

这里v指密文或者明文:n指round【len(flag)/4】正是加密,负是解密:k指密钥

魔改点：(1)(sum>> 2) & 3改为(sum >> 2)& 5 (2)delta值

将由小端序输入的flag改为正常序

for (int i = 0; i < 8; ++i) {
    printf("%c%c%c%c", (flag[i]) & 0xFF, (flag[i] >> 8) & 0xFF, (flag[i] >> 16) & 0xFF, (flag[i] >> 24) & 0xFF);
}

4)程序里面藏程序?findme你跟我搁这玩Misc呢,在遇到题目特别提示让我们找flag,且程序中的flag都是fake,有个做题新思路,main函数中的buffer变量可能含有着新的exe的二进制,以MZ,90为标志。

5)RC4魔改的点:s[i]=i变为s[i]=256-i(并且在ida中显示可能直接为-i,此时因为变量为char型,所以可以更换,而自己的代码就需要注意是否为char型,例如将Data[k]=s[t]变为Data[k]=s[256-t],此时这个t就是int型,而在ida里面绕来绕去改成char型的变量,直接显示-i)

31、3月4日

(1)汇编指令

CALL与RET为对应的指令, 如果遇到一个变量v6()这种情况, 很可能就是执行了一个call指令, 而v6的数据是RET的机械码, 若v6是输入的数据, 以此可以判断v6的部分数据为RET的机械码。

(2)AES加解密

from Crypto.Cipher import AES
import struct

data = struct.pack("<QQ",   ,  )        //>
key = b''
cipher = AES.new(key, mode=AES.MODE_ECB)
flag = cipher.decrypt(data)
print(flag)

其中struct.pack的目的是将一长串的数据改为多个byte类型的字节, '<'表示的是小端序, ‘Q'表示8个字节, ‘QQ’表示两个数, 都是8字节

(3)如果start函数识别不出main函数了, 一般离call的一个函数最近的那个函数便是main函数

(4)RSA加密

在string中找找关键词, 上面5个库都有可能, 之后google搜索lib..., 找一份可执行文件, 之后将可执行文件拖到ida中分析完成后打包退出, 之后在逆向分析的文件中点file->bindiff, 之后打开上面的打包文件(注意文件目录不能有中文), 出现很多窗口, 在一个绿色的窗口里面选中按shift下滑, 到_60-70左右, 右键impor symbols/comments, 之后返回main函数, f5反编译一下。_

(5)RSA解密

安装大数分析库

3月7日

(1)

该加密的逆向为

	for (int i = 0; i < len; i++)//求解code2
	{
		if (str[i] < 'A' || str[i]>'Z')
		{
			if (str[i] < 'a' || str[i]>'z')
			{
				if (str[i] < '0' || str[i]>'9')
					code2[i] = str[i];
				else
					code2[i] = (str[i] - 48 + 7) % 10 + 48;
			}
			else
			{
				code2[i] = (str[i] - 97 + 23) % 26 + 97;
			}
		}
		else
		{
			code2[i] = (str[i] - 65 + 23) % 26 + 65;
		}

3月13日

1)vm初体验

buuoj 网鼎杯singal 参考视频http://mtw.so/5FtEha、

4月28日

1、

application中的android:name将比主函数先运行, 可以先进去看看, 很可能不在主函数中, 而在这个函数中

而到这里后我就看不懂什么意思了, 但是主函数中的又是fake flag；后来看了wp才知道软件运行后会生成一个shell.apk,而这个路径在

直线位置是数据所在路径而后面这个我就不确定了, 也不知道是不是固定的。

5月18日

1、随机数逆向

1)相同时间戳的随机数的结果可能相同也可能不同。

2)目前遇到的题型有：srand(time(0)&0xff)

这里注意使用for i->0xff爆破, 而不是用time(0)&0xff。

5月19日

1)lua语言反编译(一般都是源码, 只有少数会编译)

unluac下载链接https://sourceforge.net/projects/unluac/files/latest/download

java -jar D:\ctf\ctf_gj\CTF_gj_Re\rehb\unluac.jar file_name>out.lua

5月20日

1)十六进制代码转程序

将上面的十六进制代码直接复制到cyberchef中, From Hex, (无需在意0x0与0x00不同, 新版cyberchef会自动填充), 之后点击图示位置保存文件

注：看了好多题解都强调用32位, 也不知道是不是这一题的缘故, 就尽量用32位吧, 不行就64再看看。

5月21日

1)对于加密：

v4:  0->len
src_2[v4] = src_2[v4] + src_2[v4 + 1] - 70;

可以解密：

v4 len->0;
src_2[v4] = src_2[v4] - src_2[v4 + 1] + 70;

2)exe文件与ELF文件的前0x40个字节是DOS MZ头, 其中最后四个字节即红框中的字节是“PE/ELF文件头偏移地址”, 意思就是从文件第一个字节开始经过多少个字节到达PE/ELF文件头。

关键注意点：(1)如果发现程序Die识别成了DOS16, 可以用010打开看一看“PE文件头偏移地址”是否正确, 当然ELF应该也是这样。当然如果没有看到PE和ELF的话, 那应该就真是个DOS16文件了。

(2)注意这里是小端序, 00 01 00 00实际上指的是0x00000100。

5月22日

1)python的使用

此图是错误使用, 可以用下图方法

2)更新了对XXTea的认识, 详情查看XXTea最下侧最新内容。

3)将有小端序char组成的DWORD改为正序

for (int i = 0; i < 8; ++i) {
    printf("%c%c%c%c", (flag[i]) & 0xFF, (flag[i] >> 8) & 0xFF, (flag[i] >> 16) & 0xFF, (flag[i] >> 24) & 0xFF);
}

4)Hook_MessageBox关键部分

关键是后半部分,

VirtualProtect(v11, 8ui64, 4u, flOldProtect);: 这行代码调用了 Windows API 中的 VirtualProtect 函数, 它用于修改指定内存区域的访问权限。在这里, 它将 v11 指向的内存区域的权限设置为 4u 所代表的权限(通常是可读)。

将v11的内存区域权限设为可读, 之后将v11指向要hook的函数, 实现hook, 所以在调用MessageBoxA时便会执行v11指向的函数。

复现经验汇总

CISCN

androidso_ez

参考文章:https://www.cnblogs.com/sK07XdAy/p/18203747

静态分析

1、当有时候代码很长的时候, 想自己猜猜加密含义时, 可喂给chatgpt一试
2、Rot13, 以前也经常见, 可就是没有仔细看看, 虽然很简单, 但可以了解了解偏移量, 喂给Cyberchef会更省事些
Rot13, 顾名思义一般情况下偏移13, 如下

//ch为大写字母
ch=(ch-'A'+13)%26+'A'
//ch为小写字母
ch=(ch='a'+13)%26+'a'

当代码块中的13改为16, 即为偏移16, 对于偏移13:chrot13(rot13(ch))而对于偏移16:chrot16(rot10(ch))
3、re真是一半靠蒙一半靠猜啊, 猜测jiejie函数为Rc4加密, 猜测Rc4加密后以此异或0x03,0x89,0x33,0xB8,0x54,0x0C,0x20,0x6A
img
4、对于源代码, 其中有key算法为AES, 加密却是DES的矛盾, 查阅资料后有以下分析：

public SecretKeySpec​(byte[] key, String algorithm)
从给定的字节数组构造一个密钥。此构造函数不检查给定的字节是否确实指定了指定算法的密钥。例如, 如果算法是DES, 则此构造函数不检查key是否为8字节长, 并且也不检查弱键或半弱键。
这句话从参考文章中偷的, 也没看太懂
img
就虽然SecretKeySpec key = new SecretKeySpec(str2, "AES");但由于SecretKeySpec()函数原因, 加密Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");依旧按照DES加密。

动态分析

asm_re

参考文章:https://blog.csdn.net/Myon5/article/details/139046502
1、处理ida跑出来的汇编代码时,如果给了下图的信息,从图中可以获取的主要信息
img

Processor       : ARM   //ARM架构
Byte sex        : Little endian     //小端序
CODE64      //64位文件

2、如果给了机械码, 我们可以把文本文件喂给gpt, 输出机械码
img
之后到010editor中新建十六进制文件, ctrl+shift+v复制进去, 之后按照给定的格式用ida打开
img
反编译即可
3、解密:emm...反编译后, 还是看不懂, 哎, 就假装我看懂了吧。之后把cipher的部分喂给gpt把密文取出来, 解密即可

#include <stdio.h>

int main() {
    unsigned int flag[] = {0x1FD7, 0x21B7, 0x1E47, 0x2027, 0x26E7, 0x10D7, 0x1127, 0x2007, 0x11C7, 0x1E47, 0x1017,
                        0x1017, 0x11F7, 0x2007, 0x1037, 0x1107, 0x1F17, 0x10D7, 0x1017,0x1F67, 0x1017, 0x11C7, 0x11C7, 0x1017, 0x1FD7, 0x1F17, 0x1107, 0x0F47, 0x1127, 0x1037, 0x1E47, 0x1037, 0x1FD7, 0x1107, 0x1FD7, 0x1107, 0x2787};
    for (int i = 0; i < 38; ++i) {
        flag[i] = flag[i] - 30;
        flag[i] ^= 0x4d;
        flag[i] -= 20;
        flag[i] /= 80;
        printf("%c", flag[i]);
    }
    return 0;
}

whereThel1b

1、看不懂,根本看不懂,果然就是快乐猜猜猜啊,也不能说没有收获
img
cpython阅读可以从string下手,很多函数看不懂,其实都有他们在py中简单的名称的,例如cpython中的__pyx_k_random在这里就能看到是random,之后交叉引用,就能尝试猜一猜如何加密了
2、对于base64可以爆破,每三个字符三个字符爆破,三个字符输出四个数据,check成功就输出.而且可以根据密文数据得到flag长度(56/4)*3

gdb_debug

1、随机数的深入研究:伪随机数列指的是以一个种子生成的随机数,它在相同的位置的值是相同的

seed=0x0;
srand(seed);
for (int j = 0; j < 38; ++j) {
    printf("0x%x, ",rand());
}

上面的代码会生成38个不同的随机数.
img

seed=0xf0000000;
for (int j = 0; j < 38; ++j) {
    srand(seed);
    printf("0x%x, ",rand());
}

而此代码只会生成38个0x26.

seed=0xf0000000;
for (int j = 0; j < 38; ++j) {
    srand(seed);
    rand();
    printf("0x%x, ",rand());
}

此代码会生成38个0x1e27.以此类推下去,不难理解伪随机数列的含义
2、在做伪随机数题目时,需要注意时linux文件还是windows文件,如果时linux文件要将脚本在linux系统下执行因为两个系统生成的随机数是不同的,但也都是伪随机数列
3、逆天,一定要注意程序生成了多少次随机数啊啊啊啊啊啊!!!!

//此处调用了38次rand()
for ( i = 0LL; ; ++i )
{
  len2 = strlen(input);
  if ( i >= len2 )
    break;
  rand_num = rand();
  *(v28 + i) = input[i] ^ rand_num;
}
//Fisher-Yates 洗牌算法的一种实现,更换数组位置
//此次调用了37次rand()
for ( j = 0LL; ; ++j )
{
    v8 = strlen(input);
    if ( j >= v8 )
    break;
    *(ptr + j) = j;
    }
for ( k = strlen(input) - 1; k; --k )
{
    v18 = rand() % (k + 1);
    v19 = *(ptr + k);
    *(ptr + k) = *(ptr + v18);
    *(ptr + v18) = v19;
}
//此处调用了38次rand
for ( n = 0LL; ; ++n )
{
    v13 = strlen(input);
    if ( n >= v13 )
      break;
    v12 = *(v31 + n);
    *(v31 + n) = rand() ^ v12;
}

故可以分别用rand1[38],rand2[37],rand[38]存放,这里很关键,如果用rand2[38],那么rand3[38]全是错的.
3、爆破的时候,一定要注意将cipher置回初始值,吐了,研究半天不知道哪里写错了,用gpt对了一下,才发现是cipher在爆破一次后值就变了,后续的爆破根本就是不成立的.
4、i*0x10000000 <=> i<<28,而不是i<<7 >
img
5、在搜索随机数的逆向的时候,发现一个挺好的题目https://blog.csdn.net/weixin_45055269/article/details/112426573
这题也是随机数的一种出题的思路,改时间戳,将随机数异或图片的数据,动态调试,将时间戳改为图片的生成时间,再异或一遍,就得到原图了.

DRK CTF

flower_tea

1、call与retn的花指令
img

call    loc_140001224   //call到loc_140001224位置, 并将栈顶设置为返回地址0x14000121F
pop     rax     //将栈顶元素(返回地址)弹到rax中
add     rax, 0Ch    //将rax加上0x0C
push    rax     //将rax入栈, 即将当前rax的值作为返回地址
retn     //读取栈顶地址(0x14000121F+0x0C)返回

2、除了IsDebuggerPresent API外, 另一个反调试检测:
在x64下, 调试标志位(BeingDebugged flag)在PEB表(Process Environment Block)偏移0x2的位置;通过获取gs寄存器找到peb表(gs:[0x60])的位置;readgsqword(0x62)得到调试标志位,读取该值如果该值为1, 表示当前进程正在被调试；如果为0, 则表示当前进程没有被调试。
img
3、之前提过, 又hook的地方肯定存在virtualprotect, 通过异或把virtualprotect函数名字改了也是逆天
img

FARPROC GetProcAddress(
HMODULE hModule,
LPCSTR  lpProcName
);

参数
hModule：这是一个模块句柄, 指向包含函数或变量的 DLL 模块。这个句柄通常由 LoadLibrary 或 GetModuleHandle 函数返回。
lpProcName：这是一个指向以空结尾的字符串, 包含要检索的函数或变量的名称, 或者包含函数的序号(由 MAKEINTRESOURCE 宏生成)。
返回值
成功时, 返回值是名称为lpProName的函数或变量的地址。
失败时, 返回值为 NULL。可以通过调用 GetLastError 函数获取更多的错误信息。

而对于ModuleName, 可能是反编译的问题, 不细究了, 下图是题解的显示
img
所以GetProcAddress()通过在kernel32.dll用到的virtualprotect获得了virtualprotect函数的地址
所以函数返回virtualprotect函数的地址
4、对virtualprotect函数的认识
img

BOOL VirtualProtect(
LPVOID lpAddress,
SIZE_T dwSize,
DWORD flNewProtect,
PDWORD lpflOldProtect
);

参数
lpAddress：指向要更改保护属性的内存区域的起始地址。必须是系统分配的页面中的地址。

dwSize：要更改保护属性的内存区域的大小(以字节为单位)。

flNewProtect：新的保护属性。可以是以下值之一(或它们的组合)：
PAGE_NOACCESS (0x01)：禁止所有访问。
PAGE_READONLY (0x02)：允许读取访问。
PAGE_READWRITE (0x04)：允许读写访问。
PAGE_WRITECOPY (0x08)：允许写入时复制访问。
PAGE_EXECUTE (0x10)：允许执行访问。
PAGE_EXECUTE_READ (0x20)：允许执行和读取访问。
PAGE_EXECUTE_READWRITE (0x40)：允许执行、读取和写入访问。
PAGE_EXECUTE_WRITECOPY (0x80)：允许执行和写入时复制访问。
PAGE_TARGETS_INVALID：指定目标区域内的所有代码地址都无效。
PAGE_TARGETS_NO_UPDATE：禁止更新目标区域内的代码地址。
lpflOldProtect：指向一个变量, 该变量接收之前的保护属性。
返回值
如果函数成功, 返回值为非零值。
如果函数失败, 返回值为零。可以调用 GetLastError 函数获取扩展错误信息。

题中第三个参数便是64(0x40),允许执行、读取和写入访问。
5、依旧是call, retn花指令
img
rsp(Register Stack Pointer)寄存器包含了当前栈的顶部地址(64位)
而esp(Extended Stack Pointer)寄存器包含了当前栈的顶部地址(32位)
与第一点相同, call后会将返回地址0x1400014BA压栈, 而

sub     qword ptr [rsp+0], 5Ah      //则将栈顶地址减去了0x5A, 即将返回地址变为了0x1400014BA-0x5A=0x140001460
mov     rdx, 1      //rdx=1
test    rdx, rdx        //rdx进行&操作, rdx还是1
jz      loc_140001489       //因为rdx为1所以不会跳转
retn

所以我们要在0x140001460位置重新反汇编, call loc_140001489与loc_140001489里的内容直接nop掉即可
此处为qword ptr [rsp+0],突然又翻到一个文章,让我对此处加深了理解 https://c10udlnk.top/p/reSkillsOn-ALLaboutJunkCode/

...:00815023 038 E8 00 00 00 00          call    $+5
...:00815028 03C 55                      push    ebp
...:00815029 040 8B EC                   mov     ebp, esp
...:0081502B                             db      36h
...:0081502B 040 36 83 45 04 0A          add     dword ptr [ebp+4], 0Ah
...:00815030 040 5D                      pop     ebp
...:00815031 03C C3                      retn

此处栈上内容(图取自上述链接)
img
dword ptr [ebp+4]就指向retn addr,注意点就是这个+4
从大佬的文章还知道一点,需要注意有没有破坏寄存器,需要更改寄存器的值(当然如果这两个寄存器后面都没用到的话当我没说x 不过保险起见, 建议还是补上最好)。
6、call, pop, jmp花指令
img
call后将0x140001648存入栈顶, pop rax将栈顶传给rax, 又jmp rax, 相当于直接retn了
7、stack frame is too big
成因：分析栈帧时有异常出现
解决方案：找到明显不合常理的stack 双击进入栈帧界面, 按U键盘删除对应的stack
有可能加壳
可能由花指令导致, 手动或自动检查并去掉花指令
img
此题是因为去花导致分析异常, 用解决方法1, 双击进入stack界面
img
按U将异常出undefine
8、对于int64转为int32

delta[0] = 0xE1C49E7259578627ui64;
delta[1] = 0x8C3DA26BBC24167Fui64;
unsigned int delta[4]={0x59578627,0xE1C49E72,0xBC24167F,0x8C3DA26B}

9、魔改tea, 可以将delta的值魔改成数组, 每次对应的delta不同

//encode:
for (int i = 0; i <15 ; i+=4) {
        for (int j = 0; j <= 32; ++j) {
            sum += delta[flag[i]%4];
            flag[i] += (sum >> 3) ^ (4 * ke[j%4]) ^ sum ^ flag[i+3];

            sum += delta[flag[i+1]%4];
            flag[i+1] += (16 * sum) ^ (ke[(j+1)%4] >> 1) ^ sum ^ flag[i];

            sum += delta[flag[i+2]%4];
            flag[i+2] += (sum >> 2) ^ (8 * ke[(j+2)%4]) ^ sum ^ flag[i+1];

            sum +=delta[flag[i+3]%4];
            flag[i+3] += (2 * sum) ^ (ke[(j+3)%4] >> 2) ^ sum ^ flag[i+2]
        }
    }
//偷的decode, 我写的感觉和以这个一样啊, 但是就是结果不对
//decode:
for (i = 0; i < len; i += 4) {
    uint32_t* c[4] = { &flag[(len - (i + 3)) % len],&flag[(len - (i + 2))
                                                          % len],&flag[(len - (i + 1)) % len],&flag[(len - i) % len] };
    for (j = 32; j >= 0; j--) {
        *c[3] -= ((e ^ *c[2]) ^ (key[(j + 3) % 4] >> 2)) ^ (e << 1);
        e -= delta[*c[3] % 4];
        *c[2] -= ((e ^ *c[1]) ^ (key[(j + 2) % 4] << 3)) ^ (e >> 2);
        e -= delta[*c[2] % 4];
        *c[1] -= ((e ^ *c[0]) ^ (key[(j + 1) % 4] >> 1)) ^ (e << 4);
        e -= delta[*c[1] % 4];
        *c[0] -= ((e ^ *c[3]) ^ (key[j % 4] << 2)) ^ (e >> 3);
        e -= delta[*c[0] % 4];
    }

elec_go

Electron(原名为Atom Shell[6])是GitHub开发的一个开源框架。[7]它通过使用Node.js(作为后端)和Chromium的渲染引擎(作为前端)完成跨平台的桌面GUI应用程序的开发。Electron现已被多个开源Web应用程序用于前端与后端的开发, 著名项目包括GitHub的Atom和微软的Visual Studio Code。[8][9]

一个基础的Electron包含三个文件：package.json(元数据)、main.js(代码)和index.html(图形用户界面)。框架由Electron可执行文件(Windows中为electron.exe、macOS中为electron.app、Linux中为electron)提供。开发者可以自行添加标志、自定义图标、重命名或编辑Electron可执行文件。

Debug

1、die没查出壳, 但是直接拖到ida中发现, 函数非常少, 很可能是进行了某些操作, 对其加密
img
既然die不行, 那就多试试别的, 就此, 我顺便把其他几个更新一下
查是查出来了,怎么脱呢,研究研究特征码之类的 https://www.52pojie.cn/thread-326995-1-1.html
根据文章得到
(1)修改区段名(UPX0...)和修改标识(3.-.-UPX!)后,die,PEid,Exeinfope都能查到
(2)去掉特征码后,只有Exeinfope可以识别出来
(3)加垃圾区段与移动PE头后,都识别不出了
(4)添加花指令还没看
2、借助x64dbg及Scylla的UPX手工脱壳
参考文章: https://bbs.kanxue.com/thread-268159.htm
就此题的学习文章:

Emoji CTF

1、之前高神视频中的rc4加密写idapy解密的问题真给遇上了,cipher中有一位为0,会导致程序执行的时候strlen的返回值变小,导致程序加密(对称密码,解密)提前结束,运行到strlen位置,pytch一下即可
img
img

2024.9

[moe ezMaze]

1、dfs处理迷宫问题

int is_obstacle(int x,int y,unsigned char *map){
    unsigned char v3;
    if ( x > 80 || y > 56 || x < 1 || y < 1 )
        return 1;
    v3 = map[10 * y - 10 + (x - 1) / 8];
    map[10 * y - 10 + (x - 1) / 8] = (1 << (7 - (x - 1) % 8)) | v3;
    return ((int)v3 >> (7 - (x - 1) % 8)) & 1;
}

(1)处理障碍问题,这个地方利用位运算标记障碍物,并且已经走过的位置被标记,不能再走.这样就导致走上错误道路时通过dfs算法无法回溯.
可以单独设置函数set obstacle

void set_obstacle(int x, int y, unsigned char *map) {
    // 将指定位置设置为障碍
    map[10 * (y - 1) + (x - 1) / 8] |= (1 << (7 - (x - 1) % 8));
}

对于set后,如果走向错误路径需要恢复现场

map[10 * (y - 1) + (x - 1) / 8] &= ~(1 << (7 - (x - 1) % 8));

(2)对于生成所有路径的方法,每一次都将可能的路段走一遍

for (int i = 0; i < 4; ++i) {
        int Newx = x, Newy = y;

        switch (option[i]) {
            case 'w':
                Newy--; // 向上
                break;
            case 's':
                Newy++; // 向下
                break;
            case 'a':
                Newx--; // 向左
                break;
            case 'd':
                Newx++; // 向右
                break;
            default:
                continue; // 不处理其他情况
        }

        // 检查边界和障碍
        if (Newx < 1 || Newx > 80 || Newy < 1 || Newy > 56 || is_obstacle(Newx, Newy, map)) {
            continue; // 继续下一个方向
        }

        path.push_back(option[i]); // 记录路径

        // 递归调用, 传递新坐标(全部路径)
        dfs_gogo(map, Newx, Newy);

        // 递归调用, 传递新坐标(单一路径)
        // if (dfs_gogo(map, Newx, Newy)) {
        // return 1; // 如果找到路径
        // }

        path.pop_back(); // 回溯
    }

具体就是分析调用dfs_gogo()函数的情况,二者区别导致前者可以输出所有路径.

以vector<vector> all_paths;存储所有路径,输出全部路径:

#include <iostream>
#include <vector>

using namespace std;

int is_obstacle(int x, int y, unsigned char *map) {
    // 检查越界
    if (x < 1 || x > 80 || y < 1 || y > 56)
        return 1; // 越界视为障碍

    // 计算映射数组的索引
    unsigned char v3 = map[10 * (y - 1) + (x - 1) / 8];

    // 返回是否为障碍
    return (v3 >> (7 - (x - 1) % 8)) & 1;
}

void set_obstacle(int x, int y, unsigned char *map) {
    // 将指定位置设置为障碍
    map[10 * (y - 1) + (x - 1) / 8] |= (1 << (7 - (x - 1) % 8));
}

char option[4] = {'w', 's', 'a', 'd'};
vector<char> path;
vector<vector<char>> all_paths; // 存储所有路径

int dfs_gogo(unsigned char *map, int x, int y) {
    // 检查是否到达目标
    if (x == 75 && y == 55) {
        all_paths.push_back(path); // 将当前路径加入所有路径
        return 1; // 找到路径
    }

    // 标记当前位置为障碍
    set_obstacle(x, y, map);

    // 遍历方向
    for (int i = 0; i < 4; ++i) {
        int Newx = x, Newy = y;

        switch (option[i]) {
            case 'w':
                Newy--; // 向上
                break;
            case 's':
                Newy++; // 向下
                break;
            case 'a':
                Newx--; // 向左
                break;
            case 'd':
                Newx++; // 向右
                break;
            default:
                continue; // 不处理其他情况
        }

        // 检查边界和障碍
        if (Newx < 1 || Newx > 80 || Newy < 1 || Newy > 56 || is_obstacle(Newx, Newy, map)) {
            continue; // 继续下一个方向
        }

        path.push_back(option[i]); // 记录路径

        // 递归调用, 传递新坐标
        dfs_gogo(map, Newx, Newy);

        path.pop_back(); // 回溯
    }

    // 取消障碍标记
    map[10 * (y - 1) + (x - 1) / 8] &= ~(1 << (7 - (x - 1) % 8));
    return 0; // 没有找到路径
}

int main() {
    unsigned char map[560] = {
            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0xFF, 0xEA, 0xA8, 0xA4, 0x92,
            0x4F, 0xFF, 0xFF, 0xFF, 0x80, 0x00, 0x3D, 0x14, 0x94, 0x92, 0xB8, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
            0xBB, 0xDA, 0x1F, 0x29, 0x7B, 0xFF, 0xFE, 0xFF, 0xC0, 0x00, 0x3B, 0xDA, 0xDC, 0x00, 0x03, 0x00,
            0x00, 0xFF, 0xDF, 0xFF, 0xFB, 0xDA, 0xDD, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xC0, 0x00, 0x3B, 0xDA,
            0xDC, 0x00, 0x03, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xB8, 0x42, 0x1F, 0xFF, 0xFB, 0xFF, 0xFE, 0xFF,
            0xC0, 0x00, 0x3F, 0xFF, 0xFC, 0x00, 0x03, 0x00, 0x00, 0xFF, 0xDF, 0xFF, 0xF8, 0x7C, 0x3D, 0xFF,
            0xFF, 0x7F, 0xFF, 0xFF, 0xC0, 0x00, 0x3B, 0xFD, 0xBC, 0x00, 0x03, 0x00, 0x3E, 0x1F, 0xFF, 0xFF,
            0xB8, 0x7C, 0x7F, 0xFF, 0xFB, 0xFF, 0xBE, 0xDF, 0xFF, 0xFF, 0xBF, 0x7D, 0xBD, 0x29, 0x7B, 0xFF,
            0xBE, 0xDF, 0xFF, 0xFF, 0x98, 0x7C, 0x3F, 0xFF, 0xFB, 0xFF, 0xBE, 0xDF, 0x80, 0x00, 0x4F, 0xFF,
            0xF8, 0x00, 0x02, 0x00, 0x3E, 0xDF, 0xBF, 0x7F, 0x6F, 0xFF, 0xFB, 0xFF, 0xFE, 0xFF, 0xFE, 0xDF,
            0x96, 0xAB, 0x60, 0x00, 0x08, 0x00, 0x02, 0x01, 0xFE, 0xDF, 0x96, 0xAB, 0x7F, 0xFF, 0xEF, 0xFF,
            0xFB, 0xFD, 0xFE, 0xDF, 0x95, 0x4B, 0x70, 0x00, 0x0C, 0x00, 0x03, 0x01, 0xFE, 0xDF, 0x95, 0x4B,
            0x77, 0xFF, 0xFD, 0xFF, 0xFF, 0x7F, 0xFE, 0xDF, 0xAA, 0x96, 0x70, 0x00, 0x0C, 0x00, 0x03, 0x00,
            0x06, 0xDF, 0x92, 0x57, 0x7F, 0xFF, 0xEF, 0xFF, 0xFB, 0xFF, 0xF6, 0xDF, 0x92, 0x94, 0x70, 0x00,
            0x0C, 0x00, 0x03, 0x00, 0x06, 0xDF, 0x8A, 0x4B, 0x77, 0xFF, 0xFD, 0xFF, 0xFF, 0x7F, 0xFE, 0xDF,
            0xAE, 0xD5, 0x70, 0x00, 0x0C, 0x00, 0x03, 0x00, 0x0E, 0xDF, 0x95, 0x4A, 0xFF, 0xFF, 0xEF, 0xFF,
            0xFB, 0xFF, 0xEE, 0xDF, 0x8A, 0x4A, 0x4A, 0x50, 0xEC, 0x00, 0x03, 0xFF, 0xEE, 0xDF, 0xBF, 0x7F,
            0x7F, 0xFF, 0xE1, 0xFF, 0xFF, 0xFF, 0xEE, 0xDF, 0xFF, 0xFF, 0xF5, 0x5D, 0x7F, 0xFF, 0xFF, 0xFF,
            0xEE, 0xDF, 0x80, 0x00, 0x38, 0xD5, 0x35, 0x2A, 0x98, 0x00, 0x0E, 0xDF, 0xBF, 0xFF, 0xBD, 0x51,
            0x2F, 0xFF, 0xFB, 0xFF, 0xFE, 0xDF, 0xA0, 0x00, 0x3F, 0xFF, 0xFC, 0x00, 0x03, 0x00, 0x00, 0xDF,
            0xAF, 0xFF, 0xFF, 0xC0, 0x7D, 0xFF, 0xFF, 0x7F, 0xFF, 0xDF, 0xA0, 0x00, 0x3F, 0xDF, 0x7C, 0x00,
            0x03, 0x00, 0x00, 0xDF, 0xBF, 0xFF, 0xBF, 0xDF, 0x7F, 0xFF, 0xFB, 0xFF, 0xFE, 0xDF, 0xA0, 0x00,
            0x3F, 0xDF, 0x7C, 0x00, 0x03, 0x00, 0x00, 0xDF, 0xAF, 0xFF, 0xFF, 0xDF, 0x7D, 0xFF, 0xFF, 0x7F,
            0xFF, 0xDF, 0xA0, 0x00, 0x3F, 0xDF, 0x7C, 0x00, 0x03, 0x00, 0x00, 0xDF, 0xBF, 0xFF, 0xBF, 0xDF,
            0x7F, 0xFF, 0xFB, 0xFF, 0xFE, 0xDF, 0xBC, 0x8B, 0xBF, 0xDF, 0x7F, 0xFF, 0xFB, 0xFF, 0xFE, 0xDF,
            0xA9, 0x24, 0x9F, 0xDF, 0x7F, 0xFF, 0xFB, 0xFF, 0xFE, 0x5F, 0xB2, 0xA1, 0xCF, 0xDF, 0x78, 0x00,
            0x02, 0x00, 0x03, 0x5F, 0xB1, 0x52, 0xEF, 0xDF, 0xFB, 0xFF, 0xFE, 0xFF, 0xFB, 0x5F, 0xAA, 0x22,
            0xE0, 0x00, 0x08, 0x00, 0x02, 0x01, 0xF8, 0x5F, 0xBD, 0x29, 0xFF, 0xFF, 0xEF, 0xFF, 0xFB, 0xFD,
            0xFF, 0xDF, 0xB2, 0x52, 0xB0, 0x00, 0x0C, 0x00, 0x03, 0x01, 0xFF, 0xDF, 0xB4, 0x94, 0xB7, 0xFF,
            0xFD, 0xFF, 0xFF, 0x7F, 0xFF, 0xDF, 0xB2, 0x4A, 0xB0, 0x00, 0x0C, 0x00, 0x03, 0x00, 0x00, 0xDF,
            0xB2, 0x52, 0x5F, 0xFF, 0xEF, 0xFF, 0xFB, 0xFF, 0xFE, 0xDF, 0xB2, 0x54, 0xD0, 0x00, 0x0C, 0x00,
            0x03, 0x00, 0x00, 0xDF, 0xB2, 0x52, 0x57, 0xFF, 0xFD, 0xFF, 0xFF, 0x7F, 0xFF, 0xDF, 0xB2, 0x91,
            0x30, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0xDF, 0xB0, 0x89, 0x7F, 0xFF, 0xFF, 0xFF, 0xF8, 0x7F,
            0xFE, 0xDF, 0xBC, 0x91, 0x10, 0xFF, 0xE0, 0x00, 0x03, 0xFF, 0xFE, 0xDF, 0x80, 0x00, 0x00, 0x00,
            0x0D, 0xFF, 0xFE, 0x94, 0x8A, 0x5F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF

    };

    int start_x = 2, start_y = 2; // 起始坐标
    dfs_gogo(map, start_x, start_y); // 从起点开始搜索

    // 输出所有路径
    for (const auto& p : all_paths) {
        for (char val : p) {
            cout << val;
        }
        cout << endl;
    }

    return 0;
}

(3)对于逆向题,肯定要在这么多路径里面确定一个正确路径,常考的便是最短路径或者给定路径长度判断.
解决方法:不仅判断x,y的位置还需要判断此时path的长度,当path.size() == taget_len时,输出路径.也可以设置一个min_path来记录当前的最短路径.最后输出最短路径.

2024.10

  1. 函数传参

    参数 1 2 3 4
    寄存器 rcx rdx r8 r9

    如果在一个函数中看到有黄色的变量,这个变量是寄存器的值,如果识别是rdx,就有可能是ida识别参数识别少了,可以手动y添加一个参数

  2. qmemcpy不是一个函数调用,是ida的优化

2024.11

  1. python学习

     import struct

 key1 = struct.pack("<4Q", 0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa)

 key2 = struct.pack("<QQQQ", 0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa, 0xaaaaaaaaaaaaaaaa)

    八字节的是Q,对于其他情况,可以点进pack函数中,向上翻,可以找到
    img

  2. 编码解码识别

     printf("%02x", x);  //十六进制编码
 sscanf(buf, "%02x", x)  //十六进制解码
    • z3的bitVec类型进行约束的时候,要<=127而不能是<128,此时会被默认为无符号类型
    • 如果只有位移运算,就用int型,可以避免bitVec类型溢出导致错误.

  4. 安装插件Diaphora,网上搜不如看Readme.
    img

  5. 报错
    img

    • 检查当前执行策略

      Get-ExecutionPolicy

    • 修改执行策略,并输入Y回车

      Set-ExecutionPolicy RemoteSigned

  6. 010无限试用将下面这个文件直接del掉即可.

     计算机\HKEY_CURRENT_USER\Software\SweetScape

2024.12

  1. Diaphora使用方法
    • 将需要对照文件(含符号表)的直接运行一遍生成filename.sqlite文件
      img
    • 打开需要对照的文件(无符号表),第二行选中step1生成的文件
      img
    • 对照方法,复制函数地址(注意不要直接复制函数名,函数名是sub_addr),在几个table中搜索找一下,之后import selected
      img

2025.1

  1. qt学习

  2. ScyllaHide

    安装https://bbs.kanxue.com/thread-284937-1.htm
    使用注意点,没开sever.exe但也成功injection,开sever后也没有回显,scylla_hide.log中有数据,scylla_hide_idaserver.log中无数据,先姑且用着,遇到其他情况再补

  3. 脚本处理靶场(判断长度)

    from pwn import *

    context(log_level='debug')

    for i in range(1, 100):
    p = remote('xxx.xxx.xxx.xxx', xxxxx)
    p.sendlineafter(b'Welcome to dance:', ('1'*i).encode())
    p.recvuntil(b'Wrong length')
    p.close()

2025.2

  1. clion编码问题,utf-8 with BOM(好像是MSCV带有的),MinGw就不需要add BOM.
  2. clion中convert是将GBK与utf-8进行转换,代码变了,显示的汉字,字符不变,reload是代码不变,显示的字符改变
  3. 遇到下面这样的,是将char转为对应的ascll码char,或者将输入的字符对应转化为ascll码的字符
    img
  4. 异常处理不能反编译可以找到一个jz(jnz)跳转过去
  5. ida Rebase
    img
  6. ida命令行中可以加上!号变为终端执行
  7. ida的python为3.12时,没有python选项
  8. __libc_start_main的初始化
    • 执行 .init 段（旧式初始化代码，可能包含 _init() 函数）。
    • 执行 .init_array 段（构造函数数组，存储全局对象的构造函数指针）。
    • 调用 main() 函数（用户编写的入口函数）。

在 _start 调用 __libc_start_main 后，按顺序执行以下操作：

  1. exe文件中,_init_array段会先于start执行,目前没什么简单的方法找到此段,只能手翻
    img
    _fini_array段会在start函数执行后执行.
    img
  2. 对ptrace的新认识

  • ptrace(PTRACE_SYSCALL, pid, 0LL, 0LL)

    • 作用：让被跟踪的进程(v1 为目标进程 PID)继续执行，但会在 进入系统调用前 和 退出系统调用后 自动暂停。
    • 返回值：若成功，返回 0；失败返回负数。循环条件 >=0 表示持续跟踪，直到发生错误。
    • 信号机制：每次目标进程触发系统调用时，内核会向其发送 SIGTRAP 信号，导致进程暂停，此时父进程(跟踪者)通过 waitpid 捕获到这一事件。
  • waitpid()的触发条件是pid对应进程的状态变化
    • 运行(Running/Runnable)
    • 可中断睡眠(Interruptible Sleep)
    • 不可中断睡眠(Uninterruptible Sleep)
    • 停止(Stopped)
    • 僵尸(Zombie)

  • while ( ptrace(PTRACE_SYSCALL, v1, 0LL, 0LL) >= 0 )

    • 第一次循环,得到syscall入口,第二次循环得到syscall出口
    • 继续执行：为了使子进程恢复运行，父进程需要调用 ptrace(PTRACE_SYSCALL, v1, 0LL, 0LL) 或 ptrace(PTRACE_CONT, v1, 0LL, 0LL)。
  1. IDA Type libraries window(类型库窗口)
  2. 多字节nop,参考: https://wiki.osdev.org/X86-64_Instruction_Encoding#32/64-bit_addressing_2

    48 0F 1F 44 00 7E nop qword ptr [rax+rax+7Eh]

常用命令

  1. android

     adb -s 设备名 shell 

    # 启动adb root
su -c "resetprop ro.debuggable 1"
su -c "resetprop service.adb.root 1" # 减少调用 adb root
su -c "magiskpolicy --live 'allow adbd adbd process setcurrent'" # 配置缺少的权限
su -c "magiskpolicy --live 'allow adbd su process dyntransition'" # 配置缺少的权限
su -c "magiskpolicy --live 'permissive { su }'" # 将 su 配置为 permissive，防止后续命令执行缺少权限
su -c "kill -9 `ps -A | grep adbd | awk '{print $2}' `" # 杀掉 adbd

  2. ubuntu

     uname -m    //查看系统架构(32/64位)
 qemu-riscv64 file_name.riscv64.elf    //运行riscv64程序
 wget https://file-name.com/file-name.tar.gz     //下载文件
 tar -zxvf file-name.tar.gz  //解压文件
 cd file-name   //进入解压后的目录
 python3 -m venv myenv   //创建虚拟环境
 source myenv/bin/activate    //激活虚拟环境

 // GDebi图形化安装deb,右键open with GDebi package install
 sudo apt install gdebi
 // dpkg命令安装deb
 sudo dpkg -i package_name.deb

  3. Windows

     sc config i8042prt start= disabled  //禁用键盘
 sc config i8042prt start= auto      //启用键盘
 Get-ExecutionPolicy                 //检查当前执行策略
 Set-ExecutionPolicy RemoteSigned    //修改执行策略,并输入Y回车
 [console]::OutputEncoding = [System.Text.Encoding]::GetEncoding("gbk")      //设置控制台输出编码为 GBK
 [console]::OutputEncoding = [System.Text.Encoding]::UTF8        //设置控制台输出编码为 UTF-8

  4. WSL

     code ~/.bashrc        //vs code打开bashrc
posted @   Un1corn  阅读(79)  评论(0)  编辑  收藏  举报
相关博文：
·  DRKCTF WP
·  复现CISCN2024 Reverse的收获
·  tea,xtea,xxtea
·  re | 逆向刷题笔记
·  TEA密码与逆向工程
阅读排行：
· winform 绘制太阳，地球，月球 运作规律
· AI与.NET技术实操系列（五）：向量存储与相似性搜索在 .NET 中的实现
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
点击右上角即可分享
微信分享提示
AI IDE Trae