2021 天翼杯 bbgo Writeup

阅读量    104196 |

分享到: QQ空间 新浪微博 微信 QQ facebook twitter

  • 关键算法: 位运算
  • 出处: 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_4830E0sub_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 的动调真的很重要很重要
分享到: QQ空间 新浪微博 微信 QQ facebook twitter
|推荐阅读
|发表评论
|评论列表
加载更多