RC4加密

一道不是很简单的 RC4 加密
例题：https://www.nssctf.cn/problem/701
此题涉及：RC4 加密，异或，base64换表，upx 脱壳。
下载附件先用 ex 查壳

32 位的 ELF 文件，有壳，直接先使用 upx 脱壳

脱完壳拖进 ida 分析，再直接查找字符串

有一个 “right!” 的字符串，点进去还可以看见其他的

交叉引用到函数，能看见代码信息

对函数逐步分析：
点进函数sub_8048AC2查看可以看出是 base 换表
下一个 for 循环就是简单的异或
接下来就是函数sub_8048E24,点进去能看见代码开头有一个函数sub_8048CC2

这些特征一看就能知道是 RC4 加密了,key=Flag{This_a_Flag},data=E8D....这一串
最后代码流程如下

• RC4解密脚本
  

1. data = [0xE8, 0xD8, 0xBD, 0x91, 0x87,0x1A,
2.         0x01, 0x0E, 0x56, 0x0F, 0x53, 0xF4,
3.         0x88, 0x96, 0x82, 0xF9, 0x61,0x42,
4.         0x0A, 0xF2,0xAB, 0x08, 0xFE, 0xD7,
5.         0xAC, 0xFD, 0x5E, 0x00]
6. key = b"Flag{This_a_Flag}"
7. def rc4(key, data):
8.         S = list(range(256))
9.         j = 0
10.         out = []
11.         for i in range(256):
12.                 j = (j + S[i] + key[i % len(key)]) % 256
13.                 S[i], S[j] = S[j], S[i]
14.         i = j = 0
15.         for T in data:
16.                 i = (i + 1) % 256
17.                 j = (j + S[i]) % 256
18.                 S[i], S[j] = S[j], S[i]
19.                 out.append(T ^ S[(S[i] + S[j]) % 256])
20.         return out
21. result = rc4(key, data)
22. new_result = "".join([chr(t) for t in result])
23. for x in new_result:
24.         print(ord(x), end=",")

复制代码

得到35,21,37,83,8,26,89,56,18,106,57,49,39,91,11,19,19,8,92,51,11,53,97,1,81,31,16,92

• 异或解密脚本
  

1. a = [35, 21, 37, 83, 8, 26,
2.      89, 56, 18, 106, 57,
3.      49, 39, 91, 11, 19,
4.      19, 8,92, 51, 11, 53,
5.      97, 1, 81, 31, 16, 92]
6. key = "Flag{This_a_Flag}"
7. length = len(key)
8. for i in range(len(a)):
9.     a[i] ^= ord(key[i % length])
10. for i in a:
11.     print(chr(i), end="")

复制代码

得到 base64 码eyD4sN1Qa5Xna7jtnN0RlN5i8lO=
用 Cyberchef 得到 flag =BJD{0v0_Y0u_g07_1T!}

需要注意的是最后用 Cyberchef base64 解码的时候需要换表，在前面函数sub_8048AC2中可以看到一个a0123456789Abcd,具体值为

RC4加密过程：

• 初始化状态向量 S（256个字节，作为密钥流生成的种子 1），按照升序，给每个字节赋值0，1，2，3，4，5，6.....，254，255
  
• 初始密钥（用户输入），长度恣意，小于 256 个字节，就举行轮转直到填满，比方密钥是 1，2，3，4，填入1，2，3，4，1，2，3，4，1，2，3，4......，轮转得到 256 个字节向量 T（密钥流生成的种子2）
  
• 根据向量 S 和 T 生成的密钥流与明文举行加密
  

1. 1.初始化 S 和 T：
2.     for i=0 to 225 do
3.         S[i]=i;
4.         T[i]=key[i mod keylen];                //限制长度
5. 2.初始排列 S
6.     j=0;
7.     for i=0 to 255 do
8.         j=(j+S[i]+T[i]) mod 256;
9.         swap(S[i],S[j]);
10. 3.产生密钥流，利用密钥流和明文加密
11.     i,j=0;
12.     for r=0 to len do                //r 为明文长度，r 字节
13.         i=(i+1) mod 256;
14.         j=(j+S[i]) mod 256;
15.         swap(S[i],S[j]);
16.         t=(S[i]+S[j]) mod 256;
17.         k[r]=S[t];
18.         data[r] ^= k[r]; //加密

复制代码

ok,over
出处：https://www.cnblogs.com/butt3rf1y本文版权归作者和博客园共有，接待转载，但必须给出原文链接，并保留此段声明，否则保留追究法律责任的权利。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。