这是我的C程序......我试图打印ESP，EBP和EIP。
#include <stdio.h>
int main() {
register int i asm("esp");
printf("%#010x <= $ESP\n", i);
int a = 1;
int b = 2;
char c[] = "A";
char d[] = "B";
printf("%p d = %s \n", &d, d);
printf("%p c = %s \n", &c, c);
printf("%p b = %d \n", &b, b);
printf("%p a = %d \n", &a, a);
register int j asm("ebp");
printf("%#010x <= $EBP\n", j);
//register int k asm("eip");
//printf("%#010x <= $EIP\n", k);
return 0;
}
我没有ESP和EBP的问题。
user@linux:~# ./memoryAddress
0xbffff650 <= $ESP
0xbffff654 d = B
0xbffff656 c = A
0xbffff658 b = 2
0xbffff65c a = 1
0xbffff668 <= $EBP
user@linux:~#
但是当我尝试输入EIP代码时，我在编译时遇到以下错误。
user@linux:~# gcc memoryAddress.c -o memoryAddress -g
memoryAddress.c: In function ‘main’:
memoryAddress.c:20:15: error: invalid register name for ‘k’
register int k asm("eip");
^
user@linux:~#
此代码有什么问题？
register int k asm("eip");
printf("%#010x <= $EIP\n", k);
是否可以通过C编程打印出EIP值？
如果是，请告诉我如何操作。
更新
我在这里测试了代码......
user@linux:~/c$ lscpu
Architecture: i686
CPU op-mode(s): 32-bit
Byte Order: Little Endian
感谢@Antti Haapala和其他人的帮助。代码有效...但是，当我将其加载到GDB时，EIP值是不同的。
(gdb) b 31
Breakpoint 1 at 0x68f: file eip.c, line 31.
(gdb) i r $eip $esp $ebp
The program has no registers now.
(gdb) r
Starting program: /home/user/c/a.out
0x00000000 <= Low Memory Address
0x40055d <= main() function
0x4005a5 <= $EIP 72 bytes from main() function (start)
0xbffff600 <= $ESP (Top of the Stack)
0xbffff600 d = B
0xbffff602 c = A
0xbffff604 b = 2
0xbffff608 a = 1
0xbffff618 <= $EBP (Bottom of the Stack)
0xffffffff <= High Memory Address
Breakpoint 1, main () at eip.c:31
31 return 0;
(gdb) i r $eip $esp $ebp
eip 0x40068f 0x40068f <main+306>
esp 0xbffff600 0xbffff600
ebp 0xbffff618 0xbffff618
(gdb)
这是新代码
#include <stdio.h>
#include <inttypes.h>
int main() {
register int i asm("esp");
printf("0x00000000 <= Low Memory Address\n");
printf("%p <= main() function\n", &main);
uint32_t eip;
asm volatile("1: lea 1b, %0;": "=a"(eip));
printf("0x%" PRIx32 " <= $EIP %" PRIu32 " bytes from main() function (start)\n",
eip, eip - (uint32_t)main);
int a = 1;
int b = 2;
char c[] = "A";
char d[] = "B";
printf("%#010x <= $ESP (Top of the Stack)\n", i);
printf("%p d = %s \n", &d, d);
printf("%p c = %s \n", &c, c);
printf("%p b = %d \n", &b, b);
printf("%p a = %d \n", &a, a);
register int j asm("ebp");
printf("%#010x <= $EBP (Bottom of the Stack)\n", j);
printf("0xffffffff <= High Memory Address\n");
return 0;
}
答案 0 :(得分：7)
请先阅读质量检查Reading program counter directly - 从那里我们可以看到没有 mov命令直接访问EIP/RIP，因此您无法使用register asm可以访问它。相反，在任何时候你都可以使用这些技巧。在64位模式下最简单，使用
uint64_t rip;
asm volatile("1: lea 1b(%%rip), %0;": "=a"(rip));
获取64位指令（感谢Michael Petch指出标签在这里与lea一起使用。
演示：
#include <stdio.h>
#include <inttypes.h>
int main(void) {
uint64_t rip;
asm volatile("1: lea 1b(%%rip), %0;": "=a"(rip));
printf("%" PRIx64 "; %" PRIu64 " bytes from main start\n",
rip, rip - (uint64_t)main);
}
然后
% gcc -m64 rip.c -o rip; ./rip
55b7bf9e8659; 8 bytes from start of main
证明它是正确的：
% gdb -batch -ex 'file ./rip' -ex 'disassemble main'
Dump of assembler code for function main:
0x000000000000064a <+0>: push %rbp
0x000000000000064b <+1>: mov %rsp,%rbp
0x000000000000064e <+4>: sub $0x10,%rsp
0x0000000000000652 <+8>: lea -0x7(%rip),%rax # 0x652 <main+8>
对于32位代码，似乎可以将lea与标签一起使用 - 但这对64位代码不起作用。
#include <stdio.h>
#include <inttypes.h>
int main(void) {
uint32_t eip;
asm volatile("1: lea 1b, %0;": "=a"(eip));
printf("%" PRIx32 "; %" PRIu32 " bytes from main start\n",
eip, eip - (uint32_t)main);
}
然后
% gcc -m32 eip.c -o eip; ./eip
5663754a; 29 bytes from main start
证明它是正确的：
% gdb -batch -ex 'file ./eip' -ex 'disassemble main'
Dump of assembler code for function main:
0x0000052d <+0>: lea 0x4(%esp),%ecx
0x00000531 <+4>: and $0xfffffff0,%esp
0x00000534 <+7>: pushl -0x4(%ecx)
0x00000537 <+10>: push %ebp
0x00000538 <+11>: mov %esp,%ebp
0x0000053a <+13>: push %ebx
0x0000053b <+14>: push %ecx
0x0000053c <+15>: sub $0x10,%esp
0x0000053f <+18>: call 0x529 <__x86.get_pc_thunk.dx>
0x00000544 <+23>: add $0x1a94,%edx
0x0000054a <+29>: lea 0x54a,%eax
（在32位版本中还有更多的lea命令，但这一个是“在这里加载我的常量地址”，然后动态链接器加载exe时将对其进行更正。
答案 1 :(得分：1)
如果您有兴趣，可以通过其他小黑客阅读rip。这里你的完整代码也是rip：
#include <stdio.h>
#include <inttypes.h>
int main()
{
register uint64_t i asm("rsp");
printf("%" PRIx64 " <= $RSP\n", i);
int a = 1;
int b = 2;
char c[] = "A";
char d[] = "B";
printf("%p d = %s \n", &d, d);
printf("%p c = %s \n", &c, c);
printf("%p b = %d \n", &b, b);
printf("%p a = %d \n", &a, a);
register uint64_t j asm("rbp");
printf("%" PRIx64 " <= $RBP\n", j);
uint64_t rip = 0;
asm volatile ("call here2\n\t"
"here2:\n\t"
"pop %0"
: "=m" (rip));
printf("%" PRIx64 " <= $RIP\n", rip);
return 0;
}
哈克这里很有趣。你只需call下一条装配线。现在因为堆栈中的返回地址为rip，您可以通过堆栈中的pop指令检索它。 :)
<强>更新
这种方法的主要原因是数据注入。请参阅以下代码：
#include <stdio.h>
#include <inttypes.h>
int main()
{
uint64_t rip = 0;
asm volatile ("call here2\n\t"
".byte 0x41\n\t" // A
".byte 0x42\n\t" // B
".byte 0x43\n\t" // C
".byte 0x0\n\t" // \0
"here2:\n\t"
"pop %0"
: "=m" (rip));
printf("%" PRIx64 " <= $RIP\n", rip);
printf("injected data:%s\n", (char*)rip);
return 0;
}
这种方法可以在代码段内注入数据（这对于代码注入很有用）。如果编译并运行，则会看到以下输出：
400542 <= $RIP
injected data:ABC
您已使用rip作为数据的占位符。我个人喜欢这种方法，但它可能会产生效率影响，如评论中所述。
我已经在64位Ubuntu bash for Windows（适用于Windows的Linux子系统）中测试了这两个代码，两者都有效。
更新2：
请务必阅读有关red zones的评论。非常感谢michael提及此问题并提供示例。 :) 如果你需要使用没有红区问题的代码，你需要按照以下方式编写它（来自micheal的样本）：
asm volatile ("sub $128, %%rsp\n\t"
"call 1f\n\t"
".byte 0x41\n\t" // A
".byte 0x42\n\t" // B
".byte 0x43\n\t" // C
".byte 0x0\n\t" // \0
"1:\n\t"
"pop %0\n\t"
"add $128, %%rsp"
: "=r" (rip));
答案 2 :(得分：1)
EIP无法直接读取。 RIP可以lea 0(%rip), %rax，但它不是通用寄存器。
您可以直接使用代码地址，而不是从寄存器中读取地址。
void print_own_address() {
printf("%p\n", print_own_address);
}
如果将其编译为PIC（与位置无关的代码），编译器将通过为您读取EIP或RIP来获取函数的运行时地址。 您不需要内联asm。
或功能以外的地址GNU C allows labels as values 。
void print_label_address() {
for (int i=0 ; i<1000; i++) {
volatile int sink = i;
}
mylabel:
for (int i=0 ; i<1000; i++) {
volatile int sink2 = i;
}
printf("%p\n", &&mylabel); // Take the label address with && GNU C syntax.
}
使用不-fPIE编译on the Godbolt compiler explorer以生成与位置无关的代码，我们得到：
# PIE version:
xor eax, eax # i=0
.L4: # do {
mov DWORD PTR -16[rsp], eax # sink=i
add eax, 1
cmp eax, 1000
jne .L4 # } while(i!=1000);
xor eax, eax # i=0
.L5: # do {
mov DWORD PTR -12[rsp], eax # sink2 = i
add eax, 1
cmp eax, 1000
jne .L5 # }while(i != 1000);
lea rsi, .L5[rip] # address of .L5 = mylabel
lea rdi, .LC0[rip] # format string
xor eax, eax # 0 FP args in XMM regs for a variadic function
jmp printf@PLT # tailcall printf
没有-fPIE，地址是链接时间常数（并且适合32位常量），所以我们得到
mov esi, OFFSET FLAT:.L5
mov edi, OFFSET FLAT:.LC0
xor eax, eax
jmp printf
是否从标签中获取有意义的地址取决于编译器如何积极地优化您放置它的代码。如果您甚至采用标签地址，那么在某处放置标签可能会阻止优化（如自动向量化），但IDK。也许只有你真正拥有goto才会受到伤害。