Binary Bomb, фаза 4, подтверждение

Question

В настоящее время я работаю над 4-й фазой этой бинарной бомбы и уже несколько часов оборачиваюсь вокруг нее. Вот мои текущие заметки.

фаза 4 разбирать

Dump of assembler code for function phase_4:
=> 0x0000000000401016 <+0>:     sub    $0x18,%rsp //rsp =-24
   0x000000000040101a <+4>:     lea    0xc(%rsp),%rcx // second input = rcx
   0x000000000040101f <+9>:     lea    0x8(%rsp),%rdx // first input = rdx 
   0x0000000000401024 <+14>:    mov    $0x4027cd,%esi // answer format is %d %d
   0x0000000000401029 <+19>:    mov    $0x0,%eax // compare 0 and eax
   0x000000000040102e <+24>:    callq  0x400c30 <__isoc99_sscanf@plt>
   0x0000000000401033 <+29>:    cmp    $0x2,%eax // compared 2 and eax
   0x0000000000401036 <+32>:    jne    0x401044 <phase_4+46> //if not equal to 2 jump to explode bomb
   0x0000000000401038 <+34>:    mov    0xc(%rsp),%eax // eax = *rsp+12(second input)
   0x000000000040103c <+38>:    sub    $0x2,%eax // subtract 2 from second input
   0x000000000040103f <+41>:    cmp    $0x2,%eax // compare 2 and second input
   0x0000000000401042 <+44>:    jbe    0x401049 <phase_4+51> // if below 2 then jump to +51
   0x0000000000401044 <+46>:    callq  0x401544 <explode_bomb>
   0x0000000000401049 <+51>:    mov    0xc(%rsp),%esi // second input becomes esi
   0x000000000040104d <+55>:    mov    $0x8,%edi // edi becomes 8
   0x0000000000401052 <+60>:    callq  0x400fde <func4> //go to func4
   0x0000000000401057 <+65>:    cmp    0x8(%rsp),%eax // compare first input to eax(from func 4)
   0x000000000040105b <+69>:    je     0x401062 <phase_4+76> //if equal go to 76
   0x000000000040105d <+71>:    callq  0x401544 <explode_bomb>
   0x0000000000401062 <+76>:    add    $0x18,%rsp
   0x0000000000401066 <+80>:    retq   

func4 разбирать

Dump of assembler code for function func4:
   0x0000000000400fde <+0>:     push   %r12 // push r12 onto stack
   0x0000000000400fe0 <+2>:     push   %rbp // push rbp onto stack
   0x0000000000400fe1 <+3>:     push   %rbx // push rbx onto stack
   0x0000000000400fe2 <+4>:     mov    %edi,%ebx // ebx becomes edi(8)
   0x0000000000400fe4 <+6>:     test   %edi,%edi // test 8 & 8
   0x0000000000400fe6 <+8>:     jle    0x40100c <func4+46> //if less than or equal to jump to 46
   0x0000000000400fe8 <+10>:    mov    %esi,%ebp // esi(second input) becomes ebp
   0x0000000000400fea <+12>:    mov    %esi,%eax // esi(second input) becomes eax
   0x0000000000400fec <+14>:    cmp    $0x1,%edi // compare 1 and edi(8)
   0x0000000000400fef <+17>:    je     0x401011 <func4+51> // if equal then jump to 51
   0x0000000000400ff1 <+19>:    lea    -0x1(%rdi),%edi // subtract 1 from edi(8) address
   0x0000000000400ff4 <+22>:    callq  0x400fde <func4> // call function 4
   0x0000000000400ff9 <+27>:    lea    (%rax,%rbp,1),%r12d
   0x0000000000400ffd <+31>:    lea    -0x2(%rbx),%edi // subtract 2 from edi address
   0x0000000000401000 <+34>:    mov    %ebp,%esi // ebp becomes esi(8)
   0x0000000000401002 <+36>:    callq  0x400fde <func4> // call func 4
   0x0000000000401007 <+41>:    add    %r12d,%eax // add r12d and eax
   0x000000000040100a <+44>:    jmp    0x401011 <func4+51> // jump to 51
   0x000000000040100c <+46>:    mov    $0x0,%eax // eax is 0
   0x0000000000401011 <+51>:    pop    %rbx
   0x0000000000401012 <+52>:    pop    %rbp
   0x0000000000401013 <+53>:    pop    %r12
   0x0000000000401015 <+55>:    retq   

и что у меня есть для заметок о том, как они работают вместе / какие входные данные предполагается, что

вход "% d% d"

второй вход должен быть 2, я думаю

идет в строку 51

второй вход становится ESI (0) после вычитания 2

EDI становится 8

превращается в удовольствие c 4

edx становится EDI (8)

test edi and edi (8 & 8)

Я смотрел на другие подобные проблемы, но мне трудно понять, как люди получили ответ на свою проблему. Я знаю, что есть кто-то, у кого был в основном тот же func4, но я не совсем понял ответ, который кто-то дал.

Я бы хотел лучше понять, что делает fun c 4. Я думаю, так как он начинается с теста между edi и edi (оба из которых равны 8), он идет к +46, что делает eax 0, но я не знаю, откуда он идет.

Я нахожусь Я уверен, что второй вход должен быть между 2 и 4, но я не знаю, что делает первый вход. Я почти уверен, что первый проходит через func4 и в итоге получается равным первому входному значению.

Я правильно понимаю, что он делает правильно?

большое спасибо.

Answer 1

Итак, глядя на func4, ваши комментарии в значительной степени повторяют то, что делает инструкция, а не то, что означает каждый ... Я предлагаю выяснить, что различные регистры содержат в любой данный момент, и, следовательно, что делается на каждом этапе , Примерно так:

Dump of assembler code for function func4:
   0x400fde <+0>:     push   %r12
   0x400fe0 <+2>:     push   %rbp
   0x400fe1 <+3>:     push   %rbx

   // Arguments: a in %edi, b in %esi 

   0x400fe2 <+4>:     mov    %edi,%ebx  // %ebx = a (copy of)
   0x400fe4 <+6>:     test   %edi,%edi
   0x400fe6 <+8>:     jle    0x40100c <func4+46> // return 0 if a <= 0

   0x400fe8 <+10>:    mov    %esi,%ebp    // %ebp = b (copy of)
   0x400fea <+12>:    mov    %esi,%eax    // %eax = b (copy of) also
   0x400fec <+14>:    cmp    $0x1,%edi
   0x400fef <+17>:    je     0x401011 <func4+51> // return b if a == 1

   // Have: a in %edi and %ebx -- a > 1; b in %esi and %ebp 

   0x400ff1 <+19>:    lea    -0x1(%rdi),%edi     // argument a for func4: a - 1
                                                 // argument b already in %esi
   0x400ff4 <+22>:    callq  0x400fde <func4>    // func4(a - 1, b)

   0x400ff9 <+27>:    lea    (%rax,%rbp,1),%r12d // r (%r12d) = b + func4(a - 1, b)

   // Have: a in %ebx -- a > 1; b in %ebp ; r = b + func4(a - 1, b) in %r12d

   0x400ffd <+31>:    lea    -0x2(%rbx),%edi     // argument a for func4: a - 2
   0x401000 <+34>:    mov    %ebp,%esi           // argument b for func4: b
   0x401002 <+36>:    callq  0x400fde <func4>    // func4(a - 2, b)

   0x401007 <+41>:    add    %r12d,%eax          // b + func4(a - 1, b) + func4(a - 2, b)
   0x40100a <+44>:    jmp    0x401011 <func4+51> // return result

   0x40100c <+46>:    mov    $0x0,%eax           // return 0

   0x401011 <+51>:    pop    %rbx
   0x401012 <+52>:    pop    %rbp
   0x401013 <+53>:    pop    %r12
   0x401015 <+55>:    retq   

Итак, теперь должна быть возможность выяснить, что делает func4(), и, следовательно, с помощью аналогичного анализа, что задумал phase_4.