2021 绿城杯 Re 逆向部分题解

ak 了 re，mark 一下

原题链接: 链接：https://pan.baidu.com/s/1lA9Y003K3AhWedge8NuQUw
提取码：1111

easy_re

签到题，本身没啥好说的，把几个花指令 nop 掉，就可以 F5 看伪代码
可以看到就是一个亦或加密，所以无需关心密钥生成，直接 dump 密钥流即可

动调起来后，输入一串 a，让程序运行到比较处时 dump 此时的 fake_cipher ，然后与字符 a 亦或即可得到密钥流

  cipher = [245, 140, 141, 228, 159, 165,  40, 101,  48, 244,
            235, 211,  36, 169, 145,  26, 111, 212, 106, 215,
            11, 141, 232, 184, 131,  74,  90, 110, 190, 203,
            244,  75, 153, 214, 230,  84, 122,  79,  80,  20,
            229, 236]
  fake_plain = b'a'*len(cipher)
  print(fake_plain)
  fake_cipher = [242, 129, 141, 226, 133, 167, 124,  97,  97, 243,
                 191, 212, 115, 229, 150,  76,  55, 208,  38, 131,
                 8, 213, 235, 244, 219,  19,   3, 105, 242, 152,
                 173,  76, 200, 131, 177,   4,  42,  25,   9,  69,
                 182, 240]
  keys = [fake_cipher[i] ^ fake_plain[i]for i in range(len(cipher))]

  flag = ''
  for i in range(len(cipher)):
    flag += chr(cipher[i] ^ keys[i])
  print(flag)

flag{c5e0f5f6-f79e-5b9b-988f-28f046117802}

babyvxworks

一个 VxWork 上的可执行文件，直接拖到 IDA 32 里面就能分析
根据交叉引用定位到主函数，发现有不少花指令

jz 和 jnz 连着用就相当于 jmp 了，所以直接把这一大片全部 patch 成 nop 即可

然后就能查看伪代码了。根据语义可以重命名一下函数

关键就在于 enc 函数了，修改一下它的函数原型，改成 void 返回值，可以发现就是一个简单的递归

由于是单字节加密，所以直接爆破即可

  cipher = [188, 10, 187, 193, 213, 134, 127, 10, 201, 185, 81, 78, 136, 10,
            130, 185, 49, 141, 10, 253, 201, 199, 127, 185, 17, 78, 185, 232, 141, 87]

  def brute():
    for i in range(len(cipher)):
      for c in range(0x20, 0x7f):
        tmp = c
        for _ in range(30):
          tmp ^= 0x22
          tmp += 3
        if tmp & 0xff == cipher[i]:
          print(chr(c), end='')
          break

  brute()

flag{helo_w0rld_W3lcome_70_R3}

抛石机

个人认为是很恶心的题…考点完全不在逆向分析而是做一些奇奇怪怪的工作…希望国内比赛这种题可以少一点
程序逻辑很简单，基本就是输入一个 uuid，每两个 byte 作为一个十六进制数，然后填充到 buffer 里，之后调用函数进行校验

然后把 buffer 的数据转换成 double ，放到一元二次方程里进行运算
随便输入一个 uuid，即可找到 uuid 和 buffer 中填充数据的对应关系，这时就确定了四个 double 都是前四个字节是 0，后四个字节是 uuid 中的数据

然后就是爆破了…跑了挺久，服了

  package main

  import (
      "encoding/binary"
      "fmt"
      "math"
      "runtime"
      "sync"
  )

  func Float64frombytes(bytes []byte) float64 {
      bits := binary.LittleEndian.Uint64(bytes)
      return math.Float64frombits(bits)
  }

  func Equation1(src float64) bool {
      ans := 149.2*src + src*-27.6*src - 129.0
      return -0.00003 <= ans && ans <= 0.00003
  }

  func Equation2(src float64) bool {
      ans := src*-39.6*src + 59.2*src + 37.8
      return -0.00003 <= ans && ans <= 0.00003
  }

  func main() {
      wg := sync.WaitGroup{}
      var a uint64
      runtime.GOMAXPROCS(runtime.NumCPU())
      eq1Solves := make([][]byte, 0)
      eq2Solves := make([][]byte, 0)
      for a = 0x0; a <= 0xffffffff; a++ {
          tA := a << 32
          f := math.Float64frombits(tA)
          wg.Add(1)
          go func() {
              tmp := make([]byte, 8)
              if Equation1(f) {
                  binary.LittleEndian.PutUint64(tmp, tA)
                  fmt.Print("1st equation solve: ")
                  fmt.Println(tA)
                  eq1Solves = append(eq1Solves, tmp)
              } else if Equation2(f) {
                  binary.LittleEndian.PutUint64(tmp, tA)
                  fmt.Print("2nd equation solve: ")
                  fmt.Println(tA)
                  eq2Solves = append(eq2Solves, tmp)
              }
              wg.Done()
          }()
      }
      wg.Wait()
      fmt.Println(eq1Solves)
      fmt.Println(eq2Solves)
  }

跑出来之后根据题目中的其他限制条件，如大小关系，解出来值的范围可以确定唯一的 flag
flag{454af13f-f84c-1140-1ee4-debf58a4ff3f}

（完）