此篇文章发布距今已超过1140天，您需要注意文章的内容或图片是否可用！
- 关键算法: 位运算
- 出处: 2021 天翼杯
- 工具: IDAPython
- 考点: Golang 恢复符号, 文件解密
- 解题技巧: 爆破
分析
恢复符号
- 这题恶心在 IDA 7.6 没法恢复符号，估计是出题人魔改了 Golang 编译器的源码或是 patch 了文件
- （我更倾向于魔改了源码，因为 Golang 初始化 runtime 的时候会对自身的 moduledata 等进行校验，patch 不太容易做到）
- 所以只能根据 Golang 恢复符号的原理手动进行恢复了，推荐这篇 Blog
- 还原本题符号的脚本如下
import idc
import ida_bytes
functable_addr = 0x4EFA20
funcstruct_addr = 0x4F4BE8
funcname_addr = 0x4BC920
ea = functable_addr
while ea < funcstruct_addr:
f_addr = idc.get_qword(ea)
fs_addr = idc.get_qword(ea+8)+functable_addr
print(hex(f_addr), hex(fs_addr))
name_addr = idc.get_wide_dword(fs_addr+8)+funcname_addr
idc.create_strlit(name_addr, idc.BADADDR)
size = ida_bytes.get_max_strlit_length(name_addr, idc.AF_ASCII)
name = idc.get_bytes(name_addr, size).decode()
idc.set_name(f_addr, name, idc.SN_NOCHECK)
ea += 16
- 然后发现绝大多数函数都能恢复了，但是
main 函数还是恢复不了，不过交叉引用一下 os_ReadFile() 就能定位到了
梳理主要逻辑
- 上来就是一个
if 判断，大胆猜测这是在比较 argc ，所以这题逻辑就是通过 argv[] 给出待加密的文件和加密文件名
- 这时候使用 findcrypt 搜一下，
main 函数里面识别出了一个 CRC_table ，推测是上来对要加密的文件生成了一个校验和
- 之后这里就要进行大量的动调了，基本就是在每次调用函数之前下个断点，函数返回之后下一个断点，用于确定函数调用的传参和返回值（参数一般通过各种寄存器传递，返回值一般就是在
rax, rcx 这些寄存器里面
- 这么做是因为 Golang 的调用约定实在是混乱，只靠 IDA 的静态分析根本没法正确识别参数和返回值
- 通过动调，可以判断出
sha1.Write() 传入的参数是栈里面的常量和 CRC 拼接起来的 bytes，然后运行 sha1.Sum() 对其进行 Hash
- 接着动调。（注意这里无需在每个函数处都下断点，因为那些
runtime 开头的函数都是 Golang 底层的一些函数，不太重要，后面需要重点关注的两个函数就是 sub_4830E0 和 sub_483580 ）
- 动调到
sub_4830E0 发现传入了刚刚 Hash 操作产生的 0x14 个 bytes，调用后在 r8 寄存器里可以发现新生成了 0xb0 个 bytes，感觉这地方是个密钥生成的函数，重命名为 genKey()
- 接着动调
sub_483580 ，发现这里头就是传入了 16 bytes 的明文和上面新生成的 bytes，因此感觉这就是加密函数了，重命名为 enc()
分析 genKey 函数
- 函数乍一看非常复杂，所以一定要动调，静态调试谁也看不懂
- 这部分感觉是值拷贝的过程，动调可以确定是把传入的
digest 数组 copy 了一份
- 然后调用
runtime.makeslice 初始化了一个数组
- 这里又是一个循环赋值操作，对比左值右值，推测应该是进行了
v47[n] = v47[n-1] + const 这样的操作，v47 就是刚刚初始化的数组，所以感觉它可能就是 keys
- 这部分就是主要的密钥生成逻辑了，不好意思，只能硬看了
- 得到密钥生成的算法如下（包括
hash 部分）
func genKey(guess1, guess2 byte) []uint32 {
var length, i, a, b, c, d, lll, index uint32
sha := sha1.New()
seed := []byte{0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, guess1, guess2}
sha.Write(seed)
rawDigest := sha.Sum(make([]byte, 0))
length = uint32(len(rawDigest))
digest := make([]uint32, 0x14)
for i = 0; i < uint32(len(rawDigest)/4); i++ {
digest[i] = binary.LittleEndian.Uint32(rawDigest[4*i : 4*(i+1)])
}
keysLen := 2*length + 4
keys := make([]uint32, keysLen)
keys[0] = 0x0BE38A40C
for i = 1; i < 2*length+4; i++ {
keys[i] = keys[i-1] + 0x48C20B1A
}
lll = uint32(3 * keysLen)
a = 0
b = 0
c = 0
d = 0
for index = 1; index <= lll; index++ {
keys[a] = bits.RotateLeft32(keys[a]+b+c, 3)
tmp1 := keys[a]
tmp2 := c + tmp1 + digest[d]
tmp3 := tmp1 + c
tmp4 := bits.RotateLeft32(tmp2, int(tmp3))
digest[d] = tmp4
c = digest[d]
tmp5 := (a + 1) % (2*uint32(length) + 4)
a = tmp5
d = (d + 1) % 4
b = tmp1
}
return keys
}
分析 enc 函数
-
enc 函数相对 genKey 来说要简单一些，如果你能分析出 genKey 的逻辑，那么分析 enc 肯定就没问题了，不断动调即可
- 得到
enc 函数的逻辑如下
func enc(crc1, crc2 byte) {
rawPlain := []byte{0x1e, 0x26, 0x2e, 0x20, 0x2b, 0x2d, 0x2f, 0x1c, 0x29, 0x22, 0x1d, 0x1f, 0x21, 0x28, 0x23, 0x27}
plain := make([]uint32, len(rawPlain)/4)
keys := genKey(crc1, crc2)
cipher := make([]uint32, 4)
length := 0x14
for i := 0; i < len(rawPlain)/4; i++ {
plain[i] = binary.LittleEndian.Uint32(rawPlain[4*i : 4*(i+1)])
}
var p, q, m, n uint32
p = plain[0]
q = keys[0] + plain[1]
m = plain[2]
n = keys[1] + plain[3]
for index := 1; index <= length; index++ {
tmp1 := bits.RotateLeft32(q*(2*q+1), 7)
tmp2 := bits.RotateLeft32(n*(2*n+1), 7)
tmp3 := bits.RotateLeft32(tmp1^p, int(tmp2))
c1 := bits.RotateLeft32(tmp2^m, int(tmp1))
p = q
q = keys[2*index+1] + c1
m = n
n = keys[2*index] + tmp3
} // b->a, d->c
cipher[0] = keys[2*length+2] + p
cipher[1] = q
cipher[2] = keys[2*length+3] + m
cipher[3] = n
}
- 然后就是对其进行逆向操作，这里尝试使用
z3 ，但是由于本题需要爆破，因为效率原因遂放弃，后来意识到因为 rol 是循环左移，不会丢失原来 uint32 中的 bits ，所以可以倒推回去
func dec(crc1, crc2 byte, realCipher []uint32) []byte {
keys := genKey(crc1, crc2)
cipher := realCipher
length := 0x14
var a, b, c, d, c1, tmp1, tmp2, tmp3 uint32
plain := make([]uint32, 4)
d = cipher[3]
c = cipher[2] - keys[2*length+3]
b = cipher[1]
a = cipher[0] - keys[2*length+2]
for index := length; index >= 1; index-- {
tmp3 = d - keys[2*index]
d = c
c1 = b - keys[2*index+1]
b = a
tmp1 = bits.RotateLeft32(b*(2*b+1), 7)
tmp2 = bits.RotateLeft32(d*(2*d+1), 7)
a = bits.RotateLeft32(tmp3, -int(tmp2)) ^ tmp1
c = bits.RotateLeft32(c1, -int(tmp1)) ^ tmp2
}
plain[0] = a
plain[1] = b - keys[0]
plain[2] = c
plain[3] = d - keys[1]
bytesPlain := []byte{}
for i := 0; i < 4; i++ {
tmp := make([]byte, 4)
binary.LittleEndian.PutUint32(tmp, plain[i])
bytesPlain = append(bytesPlain, tmp...)
}
return bytesPlain
}
解题
爆破未知的 CRC
- 现在所有部分都逆明白了，这时候需要爆破两个 byte 的 CRC
- 由于被加密的文件是 PNG 图像，所以它的头部是有特征的，这里就看解密的结果是不是存在
PNG 三个字符就行了
- 写出爆破函数
func bruteCRC() (uint8, uint8) {
var a, b int
var crc1, crc2 uint8
file, _ := os.ReadFile("flag.png.enc")
realCipher := make([]uint32, 4)
for i := 0; i < 4; i++ {
realCipher[i] = binary.LittleEndian.Uint32(file[4*i : 4*(i+1)])
}
wg := sync.WaitGroup{}
runtime.GOMAXPROCS(runtime.NumCPU())
for a = 0; a <= 0xff; a++ {
for b = 0; b < 0xff; b++ {
t1 := a
t2 := b
wg.Add(1)
go func() {
plain := dec(byte(t1), byte(t2), realCipher)
if strings.Contains(string(plain), "PNG") {
crc1 = uint8(t1)
crc2 = uint8(t2)
}
wg.Done()
}()
}
}
wg.Wait()
return crc1, crc2
}
- 爆破得到两个 bytes 是
179, 136
解密文件
- 解密文件就是很常规了，不再赘述
func fileDec(crc1, crc2 uint8) {
file, _ := os.ReadFile("flag.png.enc")
realCipher := make([]uint32, 4)
plainBytes := []byte{}
for i := 0; i < len(file); i += 16 {
for j := 0; j < 4; j++ {
realCipher[j] = binary.LittleEndian.Uint32(file[i+4*j : i+4*(j+1)])
}
tmp := dec(crc1, crc2, realCipher)
plainBytes = append(plainBytes, tmp...)
}
os.WriteFile("flag.png", plainBytes, 0777)
}
- Flag 如图所示
总结
- 文件加密题里面经常有爆破若干字节的套路
- Golang 的动调真的很重要很重要
还没有评论，来说两句吧...