ASCII 打印字符
数字 32–126 分配给了能在键盘上找到的字符，当您查看或打印文档时就会出现。数字 127 代表 DELETE 命令。
ASCII 打印字符表

十进制	十六进制	字符		十进制	十六进制	字符
32	20	space		80	50	P
33	21	!		81	51	Q
34	22	"		82	52	R
35	23	#		83	53	S
36	24	$		84	54	T
37	25	%		85	55	U
38	26	&		86	56	V
39	27	'		87	57	w
40	28	(		88	58	X
41	29	)		89	59	Y
42	2A	*		90	5A	Z
43	2B	+		91	5B	[
44	2C	,		92	5C	\
45	2D	-		93	5D	]
46	2E	.		94	5E	^
47	2F	/		95	5F	_
48	30	0		96	60	`
49	31	1		97	61	a
50	32	2		98	62	b
51	33	3		99	63	c
52	34	4		100	64	d
53	35	5		101	65	e
54	36	6		102	66	f
55	37	7		103	67	g
56	38	8		104	68	h
57	39	9		105	69	i
58	3A	:		106	6A	j
59	3B	;		107	6B	k
60	3C	<		108	6C	l
61	3D	=		109	6D	m
62	3E	>		110	6E	n
63	3F	?		111	6F	o
64	40	@		112	70	p
65	41	A		113	71	q
66	42	B		114	72	r
67	43	C		115	73	s
68	44	D		116	74	t
69	45	E		117	75	u
70	46	F		118	76	v
71	47	G		119	77	w
72	48	H		120	78	x
73	49	I		121	79	y
74	4A	J		122	7A	z
75	4B	K		123	7B	{
76	4C	L		124	7C	|
77	4D	M		125	7D	}
78	4E	N		126	7E	~
79	4F	O		127	7F	DEL

扩展 ASCII 打印字符
扩展的 ASCII 字符满足了对更多字符的需求。扩展的 ASCII 包含 ASCII 中已有的 128 个字符（数字 0–32 显示在下图中），又增加了 128 个字符，总共是 256 个。即使有了这些更多的字符，许多语言还是包含无法压缩到 256 个字符中的符号。因此，出现了一些 ASCII 的变体来囊括地区性字符和符号。
例如，许多软件程序把 ASCII 表（又称作 ISO 8859-1）用于北美、西欧、澳大利亚和非洲的语言。
扩展的ASCII 打印字符表

十进制	十六进制	字符		十进制	十六进制	字符
128	80	Ç		192	C0	└
129	81	ü		193	C1	┴
130	82	é		194	C2	┬
131	83	â		195	C3	├
132	84	ä		196	C4	─
133	85	à		197	C5	┼
134	86	å		198	C6	╞
135	87	ç		199	C7	╟
136	88	ê		200	C8	╚
137	89	ë		201	C9	╔
138	8A	è		202	CA	╩
139	8B	ï		203	CB	╦
140	8C	î		204	CC	╠
141	8D	ì		205	CD	═
142	8E	Ä		206	CE	╬
143	8F	Å		207	CF	╧
144	90	É		208	D0	╨
145	91	æ		209	D1	╤
146	92	Æ		210	D2	╥
147	93	ô		211	D3	╙
148	94	ö		212	D4	Ô
149	95	ò		213	D5	╒
150	96	û		214	D6	╓
151	97	ù		215	D7	╫
152	98	ÿ		216	D8	╪
153	99	Ö		217	D9	┘
154	9A	Ü		218	DA	┌
155	9B	¢		219	DB	█
156	9C	£		220	DC	▄
157	9D	¥		221	DD	▌
158	9E	₧		222	DE	▐
159	9F	ƒ		223	DF	▀
160	A0	á		224	E0	α
161	A1	í		225	E1	ß
162	A2	ó		226	E2	Γ
163	A3	ú		227	E3	π
164	A4	ñ		228	E4	Σ
165	A5	Ñ		229	E5	σ
166	A6	ª		230	E6	µ
167	A7	º		231	E7	τ
168	A8	¿		232	E8	Φ
169	A9	⌐		233	E9	Θ
170	AA	¬		234	EA	Ω
171	AB	½		235	EB	δ
172	AC	¼		236	EC	∞
173	AD	¡		237	ED	φ
174	AE	«		238	EE	ε
175	AF	»		239	EF	∩
176	B0	░		240	F0	≡
177	B1	▒		241	F1	±
178	B2	▓		242	F2	≥
179	B3	│		243	F3	≤
180	B4	┤		244	F4	⌠
181	B5	╡		245	F5	⌡
182	B6	╢		246	F6	÷
183	B7	╖		247	F7	≈
184	B8	╕		248	F8	≈
185	B9	╣		249	F9	∙
186	BA	║		250	FA	·
187	BB	╗		251	FB	√
188	BC	╝		252	FC	ⁿ
189	BD	╜		253	FD	²
190	BE	╛		254	FE	■
191	BF	┐		255	FF

ASCII 之外
另一个更新的字符表称为Unicode （Unicode：Unicode Consortium 开发的一种字符编码标准。该标准采用多（于一）个字节代表每一字符，实现了使用单个字符集代表世界上几乎所有书面语言）。 因为 Unicode 表大得多，它可以表示 65,536 个字符，而 ASCII 表只能表示 128 个字符，扩展的 ASCII 表也只能表示 256 个字符。这一更大的容量使不同语言的大多数字符都能包含在同一个字符集中。

---------------------
在文档中插入 ASCII 字符
注释 该功能需要 Excel、FrontPage、InfoPath、OneNote、Outlook、PowerPoint、Project、Publisher、Word 或 Visio。
除了在键盘上键入字符外，您也可以使用该符号的字符代码作为键盘快捷键。例如，要插入度数符号，在按住 ALT 的同时在数字键盘上键入 0176。
◆要从上面的图表中插入 ASCII 字符，在按住 ALT 的同时键入等价的十进制数字。
例如，要插入度数符号，在按住 ALT 的同时在数字键盘上键入 0176。
注释 必须使用数字键盘来键入数字，而不是键盘。如果您的键盘需要打开 Num Lock 键才能在数字键盘上键入数字，请务必打开它。

在使用 Makefile 之前，只需对它进行一些简单的设置即可；而且一经设置，即使以后对源程序文件有所增减一般也不再需要改动 Makefile。因此，即便是一个没有学习过 Makefile 书写规则的人，也可以为自己的 C/C++ 程序快速建立一个可工作的 Makefile。

1. 程序目录的组织
   尽量将自己的源程序集中在一个目录中，并且把 Makefile 和源程序放在一起，这样用起来比较方便。当然，也可以将源程序分类存放在不同的目录中。
   
   在程序目录中创建一个名为 Makefile 的文本文件，将后面列出的 Makefile 的内容复制到这个文件中。（注意：在复制的过程中，Makfile 中各命令前面的 Tab 字符有可能被转换成若干个空格。这种情况下需要把 Makefile 命令前面的这些空格替换为一个 Tab。）
   
   将当前工作目录切换到 Makefile 所在的目录。目前，这个 Makefile 只支持在当前目录中的调用，不支持当前目录和 Makefile 所在的路径不是同一目录的情况。
   
   
2. 指定可执行文件
   程序编译和连接成功后产生的可执行文件在 Makefile 中的 PROGRAM 变量中设定。这一项不能为空。为自己程序的可执行文件起一个有意义的名子吧。
   
   
3. 指定源程序
   要编译的源程序由其所在的路径和文件的扩展名两项来确定。由于头文件是通过包含来使用的，所以在这里说的源程序不应包含头文件。
   
   程序所在的路径在 SRCDIRS 中设定。如果源程序分布在不同的目录中，那么需要在 SRCDIRS 中一一指定，并且路径名之间用空格分隔。
   
   在 SRCEXTS 中指定程序中使用的文件类型。C/C++ 程序的扩展名一般有比较固定的几种形式：.c、.C、.cc、.cpp、.CPP、.c++、.cp、或者.cxx（参见 man gcc）。扩展名决定了程序是 C 还是 C++ 程序：.c 是 C 程序，其它扩展名表示 C++ 程序。一般固定使用其中的一种扩展名即可。但是也有可能需要使用多种扩展名，这可以在 SOURCE_EXT 中一一指定，各个扩展名之间用空格分隔。
   
   虽然并不常用，但是 C 程序也可以被作为 C++ 程序编译。这可以通过在 Makefile 中设置 CC = $(CXX) 和 CFLAGS = $(CXXFLAGS) 两项即可实现。
   
   这个 Makefile 支持 C、C++ 以及 C/C++ 混合三种编译方式：
   
   • 如果只指定 .c 扩展名，那么这是一个 C 程序，用 $(CC) 表示的编译命令进行编译和连接。
     
   • 如果指定的是除 .c 之外的其它扩展名（如 .cc、.cpp、.cxx 等），那么这是一个 C++ 程序，用 $(CXX) 进行编译和连接。
     
   • 如果既指定了 .c，又指定了其它 C++ 扩展名，那么这是 C/C++ 混合程序，将用 $(CC) 编译其中的 C 程序，用 $(CXX) 编译其中的 C++ 程序，最后再用 $(CXX) 连接程序。
     
   
   这些工作都是 make 根据在 Makefile 中提供的程序文件类型（扩展名）自动判断进行的，不需要用户干预。
   
   
4. 指定编译选项
   编译选项由三部分组成：预处理选项、编译选项以及连接选项，分别由 CPPFLAGS、CFLAGS与CXXFLAGS、LDFLAGS 指定。
   
   CPPFLAGS 选项可参考 C 预处理命令 cpp 的说明，但是注意不能包含 -M 以及和 -M 有关的选项。如果是 C/C++ 混合编程，也可以在这里设置 C/C++ 的一些共同的编译选项。
   
   CFLAGS 和 CXXFLAGS 两个变量通常用来指定编译选项。前者仅仅用于指定 C 程序的编译选项，后者仅仅用于指定 C++ 程序的编译选项。其实也可以在两个变量中指定一些预处理选项（即一些本来应该放在 CPPFLAGS 中的选项），和 CPPFLAGS 并没有明确的界限。
   
   连接选项在 LDFLAGS 中指定。如果只使用 C/C++ 标准库，一般没有必要设置。如果使用了非标准库，应该在这里指定连接需要的选项，如库所在的路径、库名以及其它联接选项。
   
   现在的库一般都提供了一个相应的 .pc 文件来记录使用库所需要的预编译选项、编译选项和连接选项等信息，通过 pkg-config 可以动态提取这些选项。与由用户显式指定各个选项相比，使用 pkg-config 来访问库提供的选项更方便、更具通用性。在后面可以看到一个 GTK+ 程序的例子，其编译和连接选项的指定就是用 pkg-config 实现的。
   
   
5. 编译和连接
   上面的各项设置好之后保存 Makefile 文件。执行 make 命令，程序就开始编译了。
   
   命令 make 会根据 Makefile 中设置好的路径和文件类型搜索源程序文件，然后根据文件的类型调用相应的编译命令、使用相应的编译选项对程序进行编译。
   
   编译成功之后程序的连接会自动进行。如果没有错误的话最终会产生程序的可执行文件。
   
   注意：在对程序编译之后，会产生和源程序文件一一对应的 .d 文件。这是表示依赖关系的文件，通过它们 make 决定在源程序文件变动之后要进行哪些更新。为每一个源程序文件建立相应的 .d 文件这也是 GNU Make 推荐的方式。
   
   
6. Makefile 目标（Targets）
   下面是关于这个 Makefile 提供的目标以及它所完成的功能：
   
   • make
     编译和连接程序。相当于 make all。
     
   • make objs
     仅仅编译程序产生 .o 目标文件，不进行连接（一般很少单独使用）。
     
   • make clean
     删除编译产生的目标文件和依赖文件。
     
   • make cleanall
     删除目标文件、依赖文件以及可执行文件。
     
   • make rebuild
     重新编译和连接程序。相当于 make clean && make all。
     

例子程序
这是一个前辈写的，非常详细
//main.cpp
int a = 0; 全局初始化区
char *p1; 全局未初始化区
main()
{
int b; 栈
char s[] = "abc"; 栈
char *p2; 栈
char *p3 = "123456"; 123456\0在常量区，p3在栈上。
static int c =0； 全局（静态）初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456"); 123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}


二、堆和栈的理论知识

2.1申请方式
stack:
由系统自动分配。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间
heap:
需要程序员自己申请，并指明大小，在c中malloc函数
如p1 = (char *)malloc(10);
在C++中用new运算符
如p2 = (char *)malloc(10);
但是注意p1、p2本身是在栈中的。

2.2申请后系统的响应
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，
会 遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内 存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大 小，系统会自动的将多余的那部分重新放入空闲链表中。

2.3申请大小的限制
栈：在 Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS 下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的 空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。


2.4申请效率的比较
栈由系统自动分配，速度较快。但程序员是无法控制的。
堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

2.5堆和栈中的存储内容
栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

2.6存取效率的比较
char s1[] = "aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在运行时刻赋值的；
而bbbbbbbbbbb是在编译时就确定的；
但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。
比如：
＃i nclude
void main()
{
char a = 1;
char c[] = "1234567890";
char *p ="1234567890";
a = c[1];
a = p[1];
return;
}
对应的汇编代码
10: a = c[1];
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]
0040106A 88 4D FC mov byte ptr [ebp-4],cl
11: a = p[1];
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]
00401070 8A 42 01 mov al,byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4],al
第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。

2.7小结
堆和栈的区别可以用如下的比喻来看出：
使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。



windows进程中的内存结构


在阅读本文之前，如果你连堆栈是什么多不知道的话，请先阅读文章后面的基础知识。

接触过编程的人都知道，高级语言都能通过变量名来访问内存中的数据。那么这些变量在内存中是如何存放的呢？程序又是如何使用这些变量的呢？下面就会对此进行深入的讨论。下文中的C语言代码如没有特别声明，默认都使用VC编译的release版。

首先，来了解一下 C 语言的变量是如何在内存分部的。C 语言有全局变量(Global)、本地变量(Local)，静态变量(Static)、寄存器变量(Regeister)。每种变量都有不同的分配方式。先来看下面这段代码：

＃i nclude <stdio.h>

int g1=0, g2=0, g3=0;

int main()
{
static int s1=0, s2=0, s3=0;
int v1=0, v2=0, v3=0;

//打印出各个变量的内存地址

printf("0x%08x\n",&v1); //打印各本地变量的内存地址
printf("0x%08x\n",&v2);
printf("0x%08x\n\n",&v3);
printf("0x%08x\n",&g1); //打印各全局变量的内存地址
printf("0x%08x\n",&g2);
printf("0x%08x\n\n",&g3);
printf("0x%08x\n",&s1); //打印各静态变量的内存地址
printf("0x%08x\n",&s2);
printf("0x%08x\n\n",&s3);
return 0;
}

编译后的执行结果是：

0x0012ff78
0x0012ff7c
0x0012ff80

0x004068d0
0x004068d4
0x004068d8

0x004068dc
0x004068e0
0x004068e4

输 出的结果就是变量的内存地址。其中v1,v2,v3是本地变量，g1,g2,g3是全局变量，s1,s2,s3是静态变量。你可以看到这些变量在内存是连 续分布的，但是本地变量和全局变量分配的内存地址差了十万八千里，而全局变量和静态变量分配的内存是连续的。这是因为本地变量和全局/静态变量是分配在不 同类型的内存区域中的结果。对于一个进程的内存空间而言，可以在逻辑上分成3个部份：代码区，静态数据区和动态数据区。动态数据区一般就是“堆栈”。“栈 (stack)”和“堆(heap)”是两种不同的动态数据区，栈是一种线性结构，堆是一种链式结构。进程的每个线程都有私有的“栈”，所以每个线程虽然 代码一样，但本地变量的数据都是互不干扰。一个堆栈可以通过“基地址”和“栈顶”地址来描述。全局变量和静态变量分配在静态数据区，本地变量分配在动态数 据区，即堆栈中。程序通过堆栈的基地址和偏移量来访问本地变量。


├———————┤低端内存区域
│ …… │
├———————┤
│ 动态数据区 │
├———————┤
│ …… │
├———————┤
│ 代码区 │
├———————┤
│ 静态数据区 │
├———————┤
│ …… │
├———————┤高端内存区域


堆 栈是一个先进后出的数据结构，栈顶地址总是小于等于栈的基地址。我们可以先了解一下函数调用的过程，以便对堆栈在程序中的作用有更深入的了解。不同的语言 有不同的函数调用规定，这些因素有参数的压入规则和堆栈的平衡。windows API的调用规则和ANSI C的函数调用规则是不一样的，前者由被调函数调整堆栈，后者由调用者调整堆栈。两者通过“__stdcall”和“__cdecl”前缀区分。先看下面这 段代码：

＃i nclude <stdio.h>

void __stdcall func(int param1,int param2,int param3)
{
int var1=param1;
int var2=param2;
int var3=param3;
printf("0x%08x\n",?m1); //打印出各个变量的内存地址
printf("0x%08x\n",?m2);
printf("0x%08x\n\n",?m3);
printf("0x%08x\n",&var1);
printf("0x%08x\n",&var2);
printf("0x%08x\n\n",&var3);
return;
}

int main()
{
func(1,2,3);
return 0;
}

编译后的执行结果是：

0x0012ff78
0x0012ff7c
0x0012ff80

0x0012ff68
0x0012ff6c
0x0012ff70


├———————┤<—函数执行时的栈顶（ESP）、低端内存区域
│ …… │
├———————┤
│ var 1 │
├———————┤
│ var 2 │
├———————┤
│ var 3 │
├———————┤
│ RET │
├———————┤<—“__cdecl”函数返回后的栈顶（ESP）
│ parameter 1 │
├———————┤
│ parameter 2 │
├———————┤
│ parameter 3 │
├———————┤<—“__stdcall”函数返回后的栈顶（ESP）
│ …… │
├———————┤<—栈底（基地址 EBP）、高端内存区域


上 图就是函数调用过程中堆栈的样子了。首先，三个参数以从又到左的次序压入堆栈，先压“param3”，再压“param2”，最后压入“param1”； 然后压入函数的返回地址(RET)，接着跳转到函数地址接着执行（这里要补充一点，介绍UNIX下的缓冲溢出原理的文章中都提到在压入RET后，继续压入 当前EBP，然后用当前ESP代替EBP。然而，有一篇介绍windows下函数调用的文章中说，在windows下的函数调用也有这一步骤，但根据我的 实际调试，并未发现这一步，这还可以从param3和var1之间只有4字节的间隙这点看出来）；第三步，将栈顶(ESP)减去一个数，为本地变量分配内 存空间，上例中是减去12字节(ESP=ESP-3*4，每个int变量占用4个字节)；接着就初始化本地变量的内存空间。由于“__stdcall”调 用由被调函数调整堆栈，所以在函数返回前要恢复堆栈，先回收本地变量占用的内存(ESP=ESP+3*4)，然后取出返回地址，填入EIP寄存器，回收先 前压入参数占用的内存(ESP=ESP+3*4)，继续执行调用者的代码。参见下列汇编代码：

;--------------func 函数的汇编代码-------------------

:00401000 83EC0C sub esp, 0000000C //创建本地变量的内存空间
:00401003 8B442410 mov eax, dword ptr [esp+10]
:00401007 8B4C2414 mov ecx, dword ptr [esp+14]
:0040100B 8B542418 mov edx, dword ptr [esp+18]
:0040100F 89442400 mov dword ptr [esp], eax
:00401013 8D442410 lea eax, dword ptr [esp+10]
:00401017 894C2404 mov dword ptr [esp+04], ecx

……………………（省略若干代码）

:00401075 83C43C add esp, 0000003C ;恢复堆栈，回收本地变量的内存空间
:00401078 C3 ret 000C ;函数返回，恢复参数占用的内存空间
;如果是“__cdecl”的话，这里是“ret”，堆栈将由调用者恢复

;-------------------函数结束-------------------------


;--------------主程序调用func函数的代码--------------

:00401080 6A03 push 00000003 //压入参数param3
:00401082 6A02 push 00000002 //压入参数param2
:00401084 6A01 push 00000001 //压入参数param1
:00401086 E875FFFFFF call 00401000 //调用func函数
;如果是“__cdecl”的话，将在这里恢复堆栈，“add esp, 0000000C”

聪明的读者看到这里，差不多就明白缓冲溢出的原理了。先来看下面的代码：

＃i nclude <stdio.h>
＃i nclude <string.h>

void __stdcall func()
{
char lpBuff[8]="\0";
strcat(lpBuff,"AAAAAAAAAAA");
return;
}

int main()
{
func();
return 0;
}

编 译后执行一下回怎么样？哈，“"0x00414141"指令引用的"0x00000000"内存。该内存不能为"read"。”，“非法操作”喽！ "41"就是"A"的16进制的ASCII码了，那明显就是strcat这句出的问题了。"lpBuff"的大小只有8字节，算进结尾的\0，那 strcat最多只能写入7个"A"，但程序实际写入了11个"A"外加1个\0。再来看看上面那幅图，多出来的4个字节正好覆盖了RET的所在的内存空 间，导致函数返回到一个错误的内存地址，执行了错误的指令。如果能精心构造这个字符串，使它分成三部分，前一部份仅仅是填充的无意义数据以达到溢出的目 的，接着是一个覆盖RET的数据，紧接着是一段shellcode，那只要着个RET地址能指向这段shellcode的第一个指令，那函数返回时就能执 行shellcode了。但是软件的不同版本和不同的运行环境都可能影响这段shellcode在内存中的位置，那么要构造这个RET是十分困难的。一般 都在RET和shellcode之间填充大量的NOP指令，使得exploit有更强的通用性。


├———————┤<—低端内存区域
│ …… │
├———————┤<—由exploit填入数据的开始
│ │
│ buffer │<—填入无用的数据
│ │
├———————┤
│ RET │<—指向shellcode，或NOP指令的范围
├———————┤
│ NOP │
│ …… │<—填入的NOP指令，是RET可指向的范围
│ NOP │
├———————┤
│ │
│ shellcode │
│ │
├———————┤<—由exploit填入数据的结束
│ …… │
├———————┤<—高端内存区域


windows下的动态数据除了可存放在栈中，还可以存放在堆中。了解C++的朋友都知道，C++可以使用new关键字来动态分配内存。来看下面的C++代码：

＃i nclude <stdio.h>
＃i nclude <iostream.h>
＃i nclude <windows.h>

void func()
{
char *buffer=new char[128];
char bufflocal[128];
static char buffstatic[128];
printf("0x%08x\n",buffer); //打印堆中变量的内存地址
printf("0x%08x\n",bufflocal); //打印本地变量的内存地址
printf("0x%08x\n",buffstatic); //打印静态变量的内存地址
}

void main()
{
func();
return;
}

程序执行结果为：

0x004107d0
0x0012ff04
0x004068c0

可以发现用new关键字分配的内存即不在栈中，也不在静态数据区。VC编译器是通过windows下的“堆(heap)”来实现new关键字的内存动态分配。在讲“堆”之前，先来了解一下和“堆”有关的几个API函数：

HeapAlloc 在堆中申请内存空间
HeapCreate 创建一个新的堆对象
HeapDestroy 销毁一个堆对象
HeapFree 释放申请的内存
HeapWalk 枚举堆对象的所有内存块
GetProcessHeap 取得进程的默认堆对象
GetProcessHeaps 取得进程所有的堆对象
LocalAlloc
GlobalAlloc

当进程初始化时，系统会自动为进程创建一个默认堆，这个堆默认所占内存的大小为1M。堆对象由系统进行管理，它在内存中以链式结构存在。通过下面的代码可以通过堆动态申请内存空间：

HANDLE hHeap=GetProcessHeap();
char *buff=HeapAlloc(hHeap,0,8);

其中hHeap是堆对象的句柄，buff是指向申请的内存空间的地址。那这个hHeap究竟是什么呢？它的值有什么意义吗？看看下面这段代码吧：

#pragma comment(linker,"/entry:main") //定义程序的入口
＃i nclude <windows.h>

_CRTIMP int (__cdecl *printf)(const char *, ...); //定义STL函数printf
/*---------------------------------------------------------------------------
写到这里，我们顺便来复习一下前面所讲的知识：
(*注)printf函数是C语言的标准函数库中函数，VC的标准函数库由msvcrt.dll模块实现。
由 函数定义可见，printf的参数个数是可变的，函数内部无法预先知道调用者压入的参数个数，函数只能通过分析第一个参数字符串的格式来获得压入参数的信 息，由于这里参数的个数是动态的，所以必须由调用者来平衡堆栈，这里便使用了__cdecl调用规则。BTW，Windows系统的API函数基本上是 __stdcall调用形式，只有一个API例外，那就是wsprintf，它使用__cdecl调用规则，同printf函数一样，这是由于它的参数个 数是可变的缘故。
---------------------------------------------------------------------------*/
void main()
{
HANDLE hHeap=GetProcessHeap();
char *buff=HeapAlloc(hHeap,0,0x10);
char *buff2=HeapAlloc(hHeap,0,0x10);
HMODULE hMsvcrt=LoadLibrary("msvcrt.dll");
printf=(void *)GetProcAddress(hMsvcrt,"printf");
printf("0x%08x\n",hHeap);
printf("0x%08x\n",buff);
printf("0x%08x\n\n",buff2);
}

执行结果为：

0x00130000
0x00133100
0x00133118

hHeap 的值怎么和那个buff的值那么接近呢？其实hHeap这个句柄就是指向HEAP首部的地址。在进程的用户区存着一个叫PEB(进程环境块)的结构，这个 结构中存放着一些有关进程的重要信息，其中在PEB首地址偏移0x18处存放的ProcessHeap就是进程默认堆的地址，而偏移0x90处存放了指向 进程所有堆的地址列表的指针。windows有很多API都使用进程的默认堆来存放动态数据，如windows 2000下的所有ANSI版本的函数都是在默认堆中申请内存来转换ANSI字符串到Unicode字符串的。对一个堆的访问是顺序进行的，同一时刻只能有 一个线程访问堆中的数据，当多个线程同时有访问要求时，只能排队等待，这样便造成程序执行效率下降。

最后来说说内存中的数据对齐。所位数 据对齐，是指数据所在的内存地址必须是该数据长度的整数倍，DWORD数据的内存起始地址能被4除尽，WORD数据的内存起始地址能被2除尽，x86 CPU能直接访问对齐的数据，当他试图访问一个未对齐的数据时，会在内部进行一系列的调整，这些调整对于程序来说是透明的，但是会降低运行速度，所以编译 器在编译程序时会尽量保证数据对齐。同样一段代码，我们来看看用VC、Dev-C++和lcc三个不同编译器编译出来的程序的执行结果：

＃i nclude <stdio.h>

int main()
{
int a;
char b;
int c;
printf("0x%08x\n",&a);
printf("0x%08x\n",&b);
printf("0x%08x\n",&c);
return 0;
}

这是用VC编译后的执行结果：
0x0012ff7c
0x0012ff7b
0x0012ff80
变量在内存中的顺序：b(1字节)-a(4字节)-c(4字节)。

这是用Dev-C++编译后的执行结果：
0x0022ff7c
0x0022ff7b
0x0022ff74
变量在内存中的顺序：c(4字节)-中间相隔3字节-b(占1字节)-a(4字节)。

这是用lcc编译后的执行结果：
0x0012ff6c
0x0012ff6b
0x0012ff64
变量在内存中的顺序：同上。

三个编译器都做到了数据对齐，但是后两个编译器显然没VC“聪明”，让一个char占了4字节，浪费内存哦。


基础知识：
堆 栈是一种简单的数据结构，是一种只允许在其一端进行插入或删除的线性表。允许插入或删除操作的一端称为栈顶，另一端称为栈底，对堆栈的插入和删除操作被称 为入栈和出栈。有一组CPU指令可以实现对进程的内存实现堆栈访问。其中，POP指令实现出栈操作，PUSH指令实现入栈操作。CPU的ESP寄存器存放 当前线程的栈顶指针，EBP寄存器中保存当前线程的栈底指针。CPU的EIP寄存器存放下一个CPU指令存放的内存地址，当CPU执行完当前的指令后，从 EIP寄存器中读取下一条指令的内存地址，然后继续执行。

 <br>

堆（Heap）栈（Stack）

1、内存分配方面：

    堆：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式是类似于链表。可能用到的关键字如下：new、malloc、delete、free等等。

    栈：由编译器(Compiler)自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、申请方式方面：

    堆：需要程序员自己申请，并指明大小。在c中malloc函数如p1 = (char *)malloc(10)；在C++中用new运算符，但是注意p1、p2本身是在栈中的。因为他们还是可以认为是局部变量。

    栈：由系统自动分配。 例如，声明在函数中一个局部变量 int b；系统自动在栈中为b开辟空间。

3、系统响应方面：

    堆：操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大 于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分 配的大小，这样代码中的delete语句才能正确的释放本内存空间。另外由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重 新放入空闲链表中。

    栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。

4、大小限制方面：

    堆：是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

    栈：在Windows下, 栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是固定的（是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。

5、效率方面：

    堆：是由new分配的内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便，另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

    栈：由系统自动分配，速度较快。但程序员是无法控制的。

6、存放内容方面：

    堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

    栈：在函数调用时第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈，然后是函数中的局部变量。 注意: 静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

7、存取效率方面：

    堆：char *s1 = "Hellow Word"；是在编译时就确定的；

    栈：char s1[] = "Hellow Word"； 是在运行时赋值的；用数组比用指针速度要快一些，因为指针在底层汇编中需要用edx寄存器中转一下，而数组在栈上直接读取。

一般面试的第一个问题肯定是叫介绍一下你自己，所以一定要准备一个1分钟左右的自我介绍。

2 请介绍一下你最熟悉的一个项目

选择一个最熟悉、和你申请的职位最match的一个项目

3 你认为你应聘这个职位有什么优势

自信大胆的说出自己的在这个项目上的优点

4 面试末尾，面试官一般会问，你还有什么问题要问吗？

具体公司具体分析

5 见面礼仪

• 保持微笑
• 面试前后要主动握手
• 表现得自信、谦虚

一个找工作的过程可以分为3个阶段，前期准备、找工作和开始工作。

1 前期准备

一般开始找工作在9月份以后了，在9月份之前的都叫做前期准备，也就是一个知识积累的阶段，这一阶段是整个找工作的基础，在这一阶段要搞清楚下面几点：

• 方向。术业有专攻，所以一定要有精通的一门技术。
• 多做项目。毕业后一定会从事研发，应聘研发职位，最重要的就是项目经验。
• 实习。能去大公司实习最好。

2 找工作

找工作是一个人一生中非常重要的一件事情，在找工作的过程中要把握好以下几点：心态、写简历、投简历、笔试、面试。

2.1心态

• 找工作是一个漫长的过程，大概有4个月左右的时间，一定要有心理准备。一个师兄说“在这几个月中，我不是在面试，就是在面试的路上”。
• 找工作的时候心情有波动，但是不要大起大落，心态要放平稳。
• 不要看到别人拿到大offer，自己的心态出现问题，做最好的自己就可以了。
• 不管受到怎样的打击，一定要坚信自己会拿到满意的offer。

2.2 写简历

• 简历非常的重要。
• 简历中要突出keyword，很多公司第一轮都是靠机器来筛选简历，所以公司要求的keyword一定要体现在简历上。
• 一个人要准备多份简历，要根据应聘公司的需要来修改自己的简历。如果这个公司只要求c++方面的，就不要把java写一大堆。
• 不要轻易写精通这个，精通那个，如果让人家知道你在欺骗人家，你就玩完了
• 项目经验4、5个就好，要把和你要投的公司相关的项目写在前面

2.3 投简历

• 投简历分为网上投简历和招聘会投简历
• 网上投简历不要急躁，一定要花至少4个小时来添那个简历，也不要快到deadline了才填，要提前2周之内搞定。
• 公司每年招聘的职位相对固定，职位要求也变化不大，所以可以提前看看你适合哪个职位，因为投简历的时候，都是按职位投得。

2.4 笔试

• 认真答完所有的题
• 如果保证无误，可以提前交卷
• 智力题可以平时多练练

2.5 面试

• 不要迟到
• 回答问题要有条理，可以先用一句话点明答案，再详细阐述，最后再总结。
• 三分钟的自我介绍很重要
• 如果问到了自己不熟的方面，可以直接说，我对某某方面的了解仅限于。。。方面，我的强项在于。。。。
• 保持微笑
• 可能面试者会故意为难你，你保持微笑
• 体现出自己的 confidence 和 smart

3 开始工作

• 先做事后做人
• 先做人后做事
• 只做人不做事

1。有三个不同的信箱，今有4封不同的信欲投其中，共有多少种不同的投法？

答案：每封信有3种投法，于是3*3*3*3。

2。连续4次抛掷一枚硬币，求恰出现两次是正面的概率和最后两次出现是正面的概率。

答案：两次正面为，0.5*0.5*0.5*0.5；最后两次为正：0.5*0.5

3。一个口袋内装有除颜色外其他都相同的6个白球和4个红球，从中任意摸出2个，求：A、2个都是白球的概率；B、2个都是红球的概率；C、一个白球，一个红球的概率。

答案：A：（6/10）×（5/9） B：（4/10）×（3/9）

      C：（6/10）×（4/9）＋（4/10）×（6/9）

4。有30支篮球队，先分3组（每组10队）按单循环制进行比赛，然后将每组前三名集中，再按单循环制进行比赛，规定在小组赛已相遇的两队不再重赛，求先后比赛共有多少场？

答案：小组赛时候次数为 3×（9＋8＋。。。＋1）

      每组前三名比赛次数3×6＋3×3

5。正方形边长为1，以各个顶点半径为1做弧，在正方形中间有一个公共区域，求面积。

答案：

6。使用下列每组数字，排出加减乘除的公式，得出“24”。第一组“1、2、3、4”
；第二组“5、6、7、8”；第三组“3、3、8、8”。

答案：A：(1+2+3)*4=24

      B：(5+7)*(8-6)=24

      C：8/(3-8/3)=24

7。10个人排队戴帽子，10个黄帽子，9个蓝帽子，戴好后，后面的人可以看见前面所有人的帽子，然后从后面问起，问自己头上的帽子是什么颜色，结果一直问了9个人都说不知道，而最前面的人却知道自己头上的帽子的颜色。问是什么颜色，为什么？

答案：

相关的题目7的还有:

################################################

一位逻辑学教授有三个学生，这三个学生都非常聪明。
一天教授想测验一下这三个学生，他在每个人头上都放了写着一个正整数的卡片，其中两个数之和等于第三个。
每个人都可以看到其他人头上的数字，但看不到自己头上的数字。
教授问第一个学生“你知道你头上的数字吗？”
第一个学生回答“不知道。”
教授接着问下去。
第二个学生回答“不知道。”
第三个学生也回答“不知道。”
教授又从头问起。
第一个学生还是回答“不知道。”
第二个学生还是回答“不知道。”
这时第三个学生说到“我知道了，是144！”

请问另两个学生头上的数字和第三个学生是怎样知道自己头上的数字的？

################################################

两个大于一小于十的整数，把两数之和告诉甲，两数之积告诉乙。让他俩猜，两人都说不知道。突然甲说我知道这两个数了，乙也跟着说我知道了。请问这两个数各是多少？

两个大于一小于十的整数，把两数之和告诉甲，两数之积告诉乙。让他俩猜，两人都说不知道。之后两人都沉思了一会儿。突然乙说我知道这两个数了，甲也跟着说我知道了。请问这两个数各是多少？

两个大于一小于十的整数，把两数之和告诉甲，两数之积告诉乙。让他俩猜，两人都说不知道。突然甲说我知道这两个数了，可乙还是不知道。请问这两个数各是多少？

################################################

一个班上有50个学生。老师对同学们说：你们中有人脸上有泥巴，请自己举起手来。连续问了七遍，所有脸上有泥巴的学生都举起了手。每个人看不到自己脸上是否有泥巴，但能观察到其他人，假设每个学生都有很聪明。问：有多少个人脸上有泥巴？

################################################

答案：（一）1.天平一边放 7+2=9 克砝码，另一边放 9 克盐。
                        2. 天平一边放 7 克砝码和刚才得到的 9 克盐，另一边放 16 克盐。
                        3. 天平一边放刚才得到的 16 克盐和再刚才得到的 9 克盐，另一边放 25 克盐。

              这些 16+9+25=50 克盐，剩下的就是 90 克盐。

 （二）

                1 70=70
                 2 35=35
                  3 20+2=15+7
                   4 （ 20+70 ） + （ 15+35 ） =140

你开着一辆车。

在一个暴风雨的晚上。

你经过一个车站。

有三个人正在等公共汽车。

一个是快要死的老人，好可怜的。

一个是医生，他曾救过你的命，是大恩人，你做梦都想报答他。

还有一个女人/男人，她/他是那种你做梦都想嫁/娶的人，也许错过就没有了。

但你的车只能坐一个人，你会如何选择那？请解释一下你的理由。

在你看下面的话之前仔细考虑一下
|
|
|
我不知道这是不是一个对你性格的测试, 因为每一个回答都有他自己的原因。

老人快要死了，你首先应该先救他。 然而，每个老人最后都只能把死作为他们的终点站, 你先让那个医生上车，因为他救过你，你认为这是个好机会报答他。 同时有些人认为一样可以在将来某个时候去报答他, 但是你一旦错过了这个机会，你可能永远不能遇到一个让你这么心动的人了。

在200个应征者中，只有一个人被雇佣了，他并没有解释他的理由，他只是说了以下的话

"给医生车钥匙，让他带着老人去医院，而我则留下来陪我的梦中情人一起等公车!"

每个人我认识的人都认为以上的回答是最好的，但没有一个人（包括我在内）一开始都没想到。

是否是因为我们从未想过要放弃我们手中已经拥有的优势（车钥匙）? 有时，如果我们能放弃一些我们的固执，狭隘，和一些优势的话，我们可能会得到更多.......

海盗分金币