邪恶博士的阴险炸弹，版本 1.1

Dr. Evil 公司允许你使用这个炸弹，但这个许可会在“受害者死亡”时失效。
公司不对挫败、疯狂、失眠、鼠标手等后果负责，除非这些事情是公司故意造成的。  
受害者不能把炸弹源码交给敌人，也不能通过调试、反汇编、运行 strings、反汇编、解密等方式了解炸弹并拆除它。  
处理炸弹时不允许穿防爆服。  
Dr. Evil 不会为自己糟糕的幽默感道歉。

/* Note to self: Remember to erase this file so my victims will have no
 * idea what is going on, and so they will all blow up in a
 * spectaculary fiendish explosion. -- Dr. Evil */

/* When run with no arguments, the bomb reads its input lines
 * from standard input. */

/* When run with one argument <file>, the bomb reads from <file>
 * until EOF, and then switches to standard input. Thus, as you
 * defuse each phase, you can add its defusing string to <file> and
 * avoid having to retype it. */

/* You can't call the bomb with more than 1 command line argument. */

/* Do all sorts of secret stuff that makes the bomb harder to defuse. */

/* Hmm... Six phases must be more secure than one phase! */

input = read_line();       /* Get input */
phase_1(input);            /* Run the phase */
phase_defused();           /* Drat! They figured it out!
                            * Let me know how they did it. */

/* The second phase is harder. No one will ever figure out
 * how to defuse this... */

/* I guess this is too easy so far. Some more complex code will
 * confuse people. */

/* Oh yeah? Well, how good is your math? Try on this saucy problem! */

/* Round and 'round in memory we go, where we stop, the bomb blows! */

/* This phase will never be used, since no one will get past the
 * earlier ones. But just in case, make this one extra hard. */

/* Wow, they got it! But isn't something... missing? Perhaps
 * something they overlooked? Mua ha ha ha ha! */

gdb ./bomb

1.系统先申请了 8 个字节的空间用于函数调用
2.系统将 0x402400 地址处的内容(变量)移到了 %esi 缓存器当中 #这意味着这个变量被调用了可能就是我们要的 string 密钥
3.系统调用了函数(strings_not_equal) # 我们估计这个就是决定是否爆炸的函数
4.系统调用了 test 测试,而这个测试需要两个输入值 #自然就是我们的输入值以及 key
5.条件判断 je(jump if equal)  即:当上面的 test 判断两个变量相等时跳转到地址 0x400ef7 # 刚好跳过下面 explode_bomb 函数
6.炸弹爆炸
7.释放函数占用的空间
8.程序结束

1. 系统先 push 两个寄存器 %rbp %rbx 入栈
2. 系统借 40 个 byte 空间, %rsp 为当前栈顶的指针
3. 将 %rsp 放进 %rsi 作为(read_six_numbers)第二个参数
4. 调用(read_six_numbers)在栈中存 6 个 4byte 数字
5. 判断 *(%rsp) == 1
6. 判断生效跳转到 0x400f30
7. 地址计算 %rbx = %rsp + 4
8. 地址计算 %rbp = %rsp + 24
9. 跳转到 0x400f17
10. /* 
12. %eax = *(%rbx - 4)
13. %eax += %eax
14. 判断 *(%rbx) == %eax
15. 判断生效跳转到 0x400f25
16. %rbx += 4
17. 判断 %rbx != %rbp
18. 判断生效跳转到 0x400f17 
19. */ 这一段开始循环 5 次
20. %eax = *(%rbx - 4)
21. %eax += %eax
22. 判断 *(%rbx) == %eax
23. 判断生效跳转到 0x400f25
24. %rbx += 4
25. 判断 %rbx != %rbp
26. 判断未生效跳转到 0x400f3c
27. 释放函数空间
28. 弹出 %rbx %rbp
29. 程序结束

1. 借用 24 字节空间
2. rcx = rsp + 12, rdx = rsp + 8
3. esi = *($0x4025cf)
4. eax = *($0x0)
5. 调函数(__isoc99_sscanf@plt)

6.判断 eax > 1
7.成立跳转 0x400f6a
8.判断 *(8 + rsp) > 7 # (8 + rsp) 则为我们刚刚 &a 的地址
9.未成立
10.eax = *(rsp + 8)
11.跳转到 *(0x402470 + 8rax)

case1: 0x400f7c
case2: 0x400fb9
case3: 0x400f83
case4: 0x400f8a
case5: 0x400f91
case6: 0x400f98
case7: 0x400f9f
case8: 0x400fa6

在初始 sscanf 读取输入时
若我们输入 a = 0
switch 语句会跳到 case1 而在 case1 不触发爆炸的条件上文已经提到
b = eax = 207
也就是说其中一组答案是 a = 0, b = 207

jbe 条件判断(jump if below or equal) 即 <=,无符号数
jle 条件判断(jump if less or equal) 即 <=,有符号数
jge 条件判断(jump if greater or equal) 即 >=
shr 位运算(shift right logic) 逻辑右移(右移时不对符号进行保留)
sar 位运算(shift right Arithmetic) 算术右移(右移时保留数的符号,比如: 最高bit位为 1 在右移后仍然保证为 1 不会自动填充为 0)

1. 先申请 24 byte 空间
2. 调用 sscanf 函数, rcx = *(rsp + 12), rdx = *(rsp + 8)
3. 判断 eax != 2 # 这里用来检查 sscanf 的返回值, eax 返回为 2 说明 sscanf 读取了两个变量
4. 未生效
5. 判断 *(rsp + 8) <= 14 # 说明 a <= 14
6. 生效跳转 0x40103a
7. 赋值 edx = 14, esi = 0, edi = *(rsp + 8) # edi = a
8. 调用 func4(esi, edx, edi);
9. 测试 test(eax & eax)
10. 判断 test(eax & eax) 为 jne(jump if not equal)
11. 未生效 # 说明 eax = 0
12. 判断 *(rsp + 12) == 0 # 此处我们可以直接得到 b = 0
13. 生效跳转 0x40105d
14. 恢复空间
15. 程序结束

eax = 0 -> 结果为 0
eax != 0 -> 结果不为 0

# 函数传入值 (esi = 0, edx = 14, edi = a)
1. 借 8 byte
2. eax = edx
3. eax -= esi # 此时 eax = (edx - esi)
4. ecx = eax
5. ecx 逻辑右移 31 位 # 获得 eax 的数字符号
6. eax += ecx # 此时 eax = (edx - esi) + ecx
7. eax 算术右移 1 位 # 即 eax = eax / 2
8. ecx = rax + rsi * 1 # ecx = eax + esi

mid = (high - low + 1) / 2 + low

9. 判断 ecx <= edi
10. 
case1 未生效(ecx > edi)
{
  edx = (rcx - 1) # 让右边界 high = mid - 1
  调用 fun4(esi,edx,edi)
  eax += eax # 理解为返回值 * 2
  函数返回
}
case2 生效(ecx <= edi)
{
  跳转 0x400ff2
  eax = 0
  判断 ecx >= edi
  case 01 生效(ecx >= edi)
  {
      函数返回 # 带着先前已经赋值的 eax = 0 返回
  }
  case 02 未生效(ecx < edi)
  {
      esi = (rcx + 1) # 相当于左边界增加 low = mid + 1
      调 func4(esi, edx, edi)
      eax = (rax + rax * 1) + 1 理解为返回值 * 2 + 1
      函数返回
  }
}

1. movzbl (mov + zero-extend + byte-to-long) 从作用变量读取一个字节的数字,零拓展后赋值给因变量
2. xor 按位异或,赋值给因变量
3. and 按位与,与上同理
4. movb (move byte) 将作用变量的一个字节数赋值给因变量

1. 存入 rbx 寄存器,取 32 字节,栈顶指针为 rsp
2. rbx = rdi # 读取调用函数的第一个参数赋值给 rbx(即字符串指针)
3. rax = *(fs + 40)
4. *(rsp + 24) = rax # 3-4步为读取栈保护值(避免栈越界)
5. eax = eax xor eax # eax = 0
6. 调 <string_length>(rbx)
7. 判断 eax == 6
8. 生效跳转 0x4010d2 # 说明输入字符串长度为 6
9. eax = 0 # 注意同时带动 rax 也变为 0
10. 跳转 0x40108b
11. ecx = *(rbx + rax * 1) # 此处 rax = 0 可以理解为读取字符串下指标 0 的字符
12. *rsp = cl # 栈顶放入刚读取的字符 cl 为 ecx 的下 8bit 数据
13. rdx = *rsp # rdx 暂存刚读取字符
14. edx = 0xf & edx # 通过按位与取该字符的前 4bit 信息
15. edx = *(rdx + 0x4024b0) # 在查找表寻找对应字符
16. *[(rsp + rax * 1) + 16] = dl # 在栈 16 地址外存入映射后的字符
17. rax++
18. 判断 rax != 6
case1 生效
{
  跳转到第 11 步 # 可见此处为循环(效果为:对输入字符串重新映射)
}
case2 未生效
{
  见下文分析
}

x/16cb 0x4024b0

0x0 -> m
0x1 -> a
0x2 -> d
0x3 -> u
0x4 -> i
0x5 -> e
0x6 -> r
0x7 -> s
0x8 -> n
0x9 -> f
0xa -> o
0xb -> t
0xc -> v
0xd -> b
0xe -> y
0xf -> l

续:
case2 未生效
  1. *(rsp + 22) = 0 # rsp 偏移 22 是因为(字符串长度为 6 + 本身的 16 偏移值 = 22),此处是给新字符串设定结束标志符'\0'
  2. esi = *(0x40245e)
  3. rdi = rsp + 16
  4. 调 <string_not_equal>(esi, rdi)
  5. 未生效跳转 0x4010d9
  6. rax = *(rsp + 24) # 取回目前栈保护值位置处的值
  7. rax = *(fs + 40) xor rax # 与真正的栈保护值异或处理
  判断
  case01 结果为 0 # 说明保护值未被覆盖栈未溢出
  {
      1. 跳转 0x4010ee
      2. 程序结束
  }
  case02 结果不为 0 # 异常栈溢出
  {
      1. 调 <_stack_chk_fail@plt>
      2. 程序报错异常
  }

x/s 0x40245e

flyers

yonuvw

Y/.u6W

1. 存入 rbx, rbp, r12, r13, r14 寄存器
2. 借 80 byte 空间,栈顶指针 rsp
3. r13 = rsp, rsi = rsp
4. 调 <read_six_numbers> # 可见本题需要输入 6 个数字
5. r14 = rsp # 至此 rsi, r13, r14 都存着数组的头指针
6. r12d = 0 # 作为遍历用的临时下标
7. rbp = r13 # 循环起始点, rbp 指向数组当前的值
8. eax = *(r13 + 0) # eax 获取该值
9. eax -= 1
10. 判断 eax <= 5
11. 生效跳转 0x401128 # 说明数组内输入的值在 1-6 范围内
12. r12d += 1
13. 判断 r12d == 6
case 1 生效
{
    # 进入 case 1 时, r12d = 6
    c1-1. 跳转 0x401153
    c1-2. rsi = rsp +24 # rsi 指向数组的末尾的后一位
    c1-3. rax = r14 # rax 指向数组的头地址
    c1-4. ecx = 7
    c1-5. edx = ecx # 循环起始点
    c1-6. edx -= *(rax) # edx = 7 - 当前下标处的数值
    c1-7. *(rax) = edx # 替换原数组数值
    c1-8. rax += 4 # 遍历下一位
    c1-9. 判断 rax != rsi
    case 01 生效
    {
        跳转 0x401160(即回到 c1-5. )
    }
    case 02 未生效
    {
        # 第二大部分后文接着讲
    }
    # 可见 case1 处的小循环作用是数据处理,将数组内每个数做 (7 - 当前数) 处理,便于后续操作
}
case 2 未生效
{
    c2-1. ebx = r12d # 初次进入时 r12d = 1
    c2-2. rax = ebx # 循环起始点,ebx 作为遍历的临时下标
    c2-3. eax = *(rsp + rax * 4) # eax 获取下标处数值
    c2-4. 判断 *(rbp + 0) != rax
    c2-5. 生效跳转 0x401145
    c2-6. ebx += 1
    c2-7. 判断 ebx <= 5
    case 01 生效 
    {
        跳转 0x401135(即回到 c2-2. )
    }
    case 02 未生效
    {
        c2-c02-1. r13 += 4 # 将 r13 下标向后挪一位
        c2-c02-2. 跳转 0x401114(即回到 7. )
    }
} # 至此可以明白 case2 是大循环内的小循环用来确保输入的 6 个数互不相同且数字范围在 1-6 ,若有相同数则爆炸

续:
case1
{
    case02
    {
        c1-c02-1. esi = 0 # 同时让 rsi = 0
        c1-c02-2. 跳转 0x401197
        c1-c02-3. ecx = *(rsp + rsi * 1) # 循环起始点
        c1-c02-4. 判断 ecx <= 1
        case 01 生效 # 即原输入数字为 6 的情况
        {
            c1-c02-c01-1. 跳转 0x401183
            c1-c02-c01-2. edx = 0x6032d0 # 作为链表的头节点地址
            c1-c02-c01-3. 同样内容(前往 c1-c02-c02-c02-2. 可见)
        }
        case 02 未生效
        {
            c1-c02-c02-1. eax = 1 # 用来记录存入的节点数
            c1-c02-c02-2. edx = 0x6032d0
            c1-c02-c02-3. 跳转 0x401176
            c1-c02-c02-4. rdx = *(rdx + 8) 
            ```
              循环起始点, 8 是一个节点的空间大小,此处类似链表的写法 (cur = cur->next)
            ```
            c1-c02-c02-5. eax += 1
            c1-c02-c02-6. 判断 eax != ecx 
            ```
              已知 ecx 是当前遍历的数的数值,而 eax 为计数器,此处要求 cur指针 遍历次数为 ecx 次才结束,可以合理推测 ecx 为输入数的序号(即预处理后的数为序号)
            ```
            case 01 生效
            {
                跳转 0x401176(即回到 c1-c02-c02-4. )
            }
            case 02 未生效
            {
                c1-c02-c02-c02-1. 跳转到 0x401188
                c1-c02-c02-c02-2. *[(rsp + rsi * 2) + 32] = rdx 
                ```
                  此处为偏移值将 edx 的值放在 (rsp + 32 + 下标 * 2) 的位置上,对于输入 6 的特殊情况则是将该 6 的节点作为头节点存入
                ```
                c1-c02-c02-c02-3. rsi += 4 # 下标后移
                c1-c02-c02-c02-4. 判断 rsi == 24
                case 01 生效
                {
                    # 第三大部分后面接着讲
                }
                case 02 未生效
                {
                    同样内容(前往 c1-c02-3. 可见)
                }
            }
        }
    }
}

栈上: (&节点4) (&节点1) (&节点6) (&节点3) (&节点2) (&节点5)
数组:   [1]      [2]      [3]      [4]      [5]      [6]

case ../
{
    ../1. 跳转 0x4011ab
    ../2. rbx = *(rsp + 32) # 这里 rbx 为链表的头结点
    ../3. rax = rsp + 40 # 头结点的 next 地址
    ../4. rsi = rsp + 80 # 链表尾数据地址
    ../5. rcx = rbx # 存储头结点到 rcx
    ../6. rdx = *(rax) # 循环起始点, rdx 为当前遍历的节点
    ../7. *(rcx + 8) = rdx # 让头结点指向当前遍历的节点
    ../8. rax += 8
    ../9. 判断rax == rsi
    case 01 生效
    {
        ../c01-1. 跳转 0x4011d2
        ../c01-2. *(rdx + 8) = 0 # 设置末节点的 next 为 0 即 NULL
        ../c01-3. ebp = 5
        ../c01-4. rax = *(rbx + 8) # 循环起始点
        ../c01-5. eax = *(rax)
        ../c01-6. 判断 *(rbx) >= eax
        ../c01-7. 生效跳转 0x4011ee
        ../c01-8. rbx = *(rbx + 8)
        ../c01-9. ebp -= 1
        ../c01-10. 判断 ebp != 0
        case 01 生效
        {
            ```
              这段是确保链表里存的值是一个单调不增的结构(如: 7 6 5 5 3 1),若出现前一个数小于后一个数则爆炸  
              而它的检查顺序是按照我们之前在栈上输入的序号顺序而组成的链表进行检查
            ```
            跳转 0x4011df(即回到 ../c01-4.)
        } 
        case 02 未生效
        {
            ../c01-c02.1 恢复栈空间
            ../c01-c02.2 程序结束
        }
    }
    case 02 未生效
    {
        ```
          这里各位可以自己试着画下图来稿清楚各个指针的作用,大体上是把链表串起来,之前只是各个节点地址被存在栈上,但是链表本身并没有串起来,这里就是这个功用
        ```
        ../c02-1. rcx = rdx
        ../c02-2. 跳转 0x4011bd(即回到 ../6.)
    }
}

x/wd 0x6032d0 # 0x6032d0 为链表头的地址
x/gx 0x6032d8 # (头指针地址 + 8) 看 next 指向的下一个地址

0x6032d0 332
0x6032e0 168
0x6032f0 924
0x603300 691
0x603310 477
0x603320 443
0x0

332 168 924 691 477 443
[1] [2] [3] [4] [5] [6]

3 4 5 6 1 2 # 这个为我们选择的顺序

4 3 2 1 6 5

<secret_phase>

1. num_input_strings != 6, 不能成立
2. sscanf 读取目数 != 3, 不能成立
3. strings_not_equal 返回非 0, 不能成立

1. 6 个 phase 都正常通过
2. 在 phase_4 调用 sscanf 的时候除了答案的两个数,还需要写入一个字符串成功让 strings_not_equal 返回 0(即相等)

sscanf 读取的时候读取地址是 0x603870  
意味着判断的输入行是 0x603870 处的输入

我们可以输入 info address input_strings 会返回:
  Symbol "input_strings" is at 0x603780 in a file compiled.

这说明输入槽从 0x603780 开始,那么到 0x603870 是哪个 phase 呢?

0x603870 - 0x603780 = 0xf0 = 240

但是每个 phase 的输入间隔是多少呢?

为此我们需要反汇编 read_line 函数才能知道

   0x000000000040151f <+129>:	mov    0x20223b(%rip),%edx        # 0x603760 <num_input_strings>
   0x0000000000401525 <+135>:	movslq %edx,%rax
   0x0000000000401528 <+138>:	lea    (%rax,%rax,4),%rsi
   0x000000000040152c <+142>:	shl    $0x4,%rsi
   0x0000000000401530 <+146>:	add    $0x603780,%rsi
   0x0000000000401537 <+153>:	mov    %rsi,%rdi

x/s 0x402622

DrEvil

这里是个考验 递归+二叉树 知识的题目
本题通过 func7 递归查找数,每往深的一层探索:
    1.左移 -> 子调用返回值 * 2
    2.右移 -> 子调用返回值 * 2 + 1
    3.发现寻找的数时返回 0

而本题要求 func7 最终返回值为 2

                         36
                  /             \
                 8               50
              /     \          /     \
             6       22       45      107
            / \     /  \     / \      /  \
           1   7   20  35   40  47   99  1001

1. 左->右->左(20)
2. 左->右(22)