使用 EBX 寄存器进行内存访问的模式是什么？

我正在学习逆向工程的基础知识。在逆向crackme时，我碰巧在几乎每个函数的开头都看到了这种模式：

pushl %ebp                            
movl  %esp, %ebp              
pushl %ebx              # because ebx is a callee-saved register
subl  $0x14,%esp        # of course $0x14 changes depending on the function
calll 0x08048766
addl  $0x1a5f, %ebx     # also this value sometime changes depending on the function

在哪里0x08048766有一个函数可以做到这一点：

movl 0(%esp), %ebx         
retl 

所以基本上，正如正常的那样，每个函数首先初始化寄存器ebp and esp。然后注册ebx被压入堆栈，这也是完全可以理解的ebx是一个被调用者保存的寄存器，稍后在函数中使用它来引用一些静态数据（来自.rodata）， 例如：

leal  -0x17b7(%ebx), %eax
movl  %eax, 0(%esp) 
calll printf   

现在是最有趣（对我来说也是晦涩难懂）的部分：如果我理解正确的话，ebx首先用指向的值进行初始化esp（这使用了函数0x08048766）， 为什么？里面有什么？这不是堆栈中未初始化的点吗？

然后将另一个值添加到ebx。这个值代表什么？

我想更好地了解如何注册ebx在这种情况下使用，以及如何计算它所指向的地址。

你可以看一下完整的程序here https://github.com/Maijin/Workshop2015/blob/master/IOLI-crackme/bin-linux/crackme0x09，但不幸的是没有任何可用的 C 源代码。

这段代码似乎是用-fPIC。 PIC 代表“位置无关代码”，这意味着它可以加载到任何地址，并且仍然能够访问其全局变量。

在这种情况下ebx被称为PIC寄存器，它用于指向GOT（全局偏移表）的末尾。 GOT 具有到所使用的每个全局变量的偏移量（从程序的基地址*）。

很多时候，了解这些事情的最好方法是自己编译一些代码，然后查看输出。当您有符号可供查看时，它尤其会变得更容易。

我们来做一个实验：

pic.c

int global;

int main(void)
{
    global = 4;
    return 0;
}

Compile

$ gcc -v
...
gcc version 5.3.1 20160406 (Red Hat 5.3.1-6) (GCC)

$ gcc -m32 -Wall -Werror -fPIC -o pic pic.c

Sections（略）

$ readelf -S pic
Section Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [13] .text             PROGBITS        080482f0 0002f0 000182 00  AX  0   0 16
  [15] .rodata           PROGBITS        08048488 000488 00000c 00   A  0   0  4
  [22] .got              PROGBITS        08049ffc 000ffc 000004 04  WA  0   0  4
  [23] .got.plt          PROGBITS        0804a000 001000 000014 04  WA  0   0  4
  [24] .data             PROGBITS        0804a014 001014 000004 00  WA  0   0  1
  [25] .bss              NOBITS          0804a018 001018 000008 00  WA  0   0  4

拆卸（英特尔语法，因为 AT&T 让我抓狂）

$ objdump -Mintel -d --no-show-raw-insn pic

080483eb <main>:
 80483eb:   push   ebp
 80483ec:   mov    ebp,esp
 80483ee:   call   804840b <__x86.get_pc_thunk.ax> ; EAX = EIP + 5
 80483f3:   add    eax,0x1c0d            ; EAX = 0x804a000 (.got.plt, end of .got)
 80483f8:   lea    eax,[eax+0x1c]        ; EAX = 0x804a01C (.bss + 4)

 80483fe:   mov    DWORD PTR [eax],0x4   ; set `global` to 4
 8048404:   mov    eax,0x0
 8048409:   pop    ebp
 804840a:   ret    

0804840b <__x86.get_pc_thunk.ax>:
 804840b:   mov    eax,DWORD PTR [esp]
 804840e:   ret    
 804840f:   nop

解释

在这种情况下，我的 GCC 决定使用eax作为 PIC 寄存器而不是ebx.

另外，请注意编译器（GCC 5.3.1）在这里做了一些有趣的事情。它不是通过 GOT 访问变量，而是本质上使用 GOT 作为“锚点”，而是直接偏移到变量中.bss部分。

回到你的代码：

pushl %ebp                            
movl %esp, %ebp              
pushl %ebx             ; because ebx is a callee-saved register
subl $0x14,%esp        ; end of typical prologue 

calll 0x08048766       ; __i686_get_pc_thunk_bx
                       ; Gets the current value of EIP after this call into EBX.
                       ; There is no other way to do this in x86 without a call

addl $0x1a5f, %ebx     ; Add the displacement to the end of the GOT.
                       ; This displacement of course changes depending on 
                       ; where the function is.
                       ; EBX now points to the end of the GOT.

leal -0x17b7(%ebx), %eax    ; EAX = EBX - 0x17b7
movl %eax, 0(%esp)          ; Put EAX on stack (arg 0 to printf)
                            ; EAX should point to some string
calll printf   

在您的代码中，它实际上并没有“使用”GOT（否则我们会看到第二个内存取消引用）；它使用它作为字符串的锚点，可能在只读数据部分（.rodata) 也出现在 GOT 之前。

如果你看一下这个函数0x08048766，你会看到它看起来像这样：

mov    (%esp),%eax  ; Put return address (pushed onto stack by call insn)
                    ; in eax
ret                 ; Return