第十一章、内存管理和安全性

11、内存管理和安全性

11.1 内存管理

11.1.1 内存分配方式

内存分配方式有三种:
(1) 从静态存储区域分配。
内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static 变量。
(2) 在栈上创建。
在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集 中,效率很高,但是分配的内存容量有限。
(3)从堆上分配,亦称动态内存分配。
程序在运行的时候用 malloc 或 new 申请任意多 少的内存,程序员自己负责在何时用 free 或 delete 释放内存。动态内存的生存期 由我们决定,使用非常灵活,但问题也最多。

11.1.2 常见的内存错误及其对策

1)内存分配未成功,却使用了它。

编程新手常犯这种错误,因为他们没有意识到内存分配会不成功。常用解决办法是, 在使用内存之前检查指针是否为 NULL。如果指针 p 是函数的参数,那么在函数的入口 处用 assert(p!=NULL)进行检查。如果是用 malloc 或 new 来申请内存,应该用 if(p==NULL) 或 if(p!=NULL)进行防错处理。

2)内存分配虽然成功,但是尚未初始化就引用它。

犯这种错误主要有两个起因:一是没有初始化的观念;二是误以为内存的缺省初值全为零,导致引用初值错误(例如数组)。 内存的缺省初值究竟是什么并没有统一的标准,尽管有些时候为零值,我们宁可信其无不可信其有。所以无论用何种方式创建数组,都别忘了赋初值,即便是赋零值也不可省略,不要嫌麻烦。

3)内存分配成功并且已经初始化,但操作越过了内存的边界。

例如在使用数组时经常发生下标“多 1”或者“少 1”的操作。特别是在 for 循环语
句中,循环次数很容易搞错,导致数组操作越界。

4)忘记了释放内存,造成内存泄露。

含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足,你
看不到错误。终有一次程序突然死掉,系统出现提示:内存耗尽。 动态内存的申请与释放必须配对,程序中 malloc 与 free 的使用次数一定要相同,否则肯定有错误(new/delete 同理)。

5)释放了内存却继续使用它。

有三种情况:
(1) 程序中的对象调用关系过于复杂,实在难以搞清楚某个对象究竟是否已经释放了内存,此时应该重新设计数据结构,从根本上解决对象管理的混乱局面。
(2) 函数的 return 语句写错了,注意不要返回指向“栈内存”的“指针”或者“引用”, 因为该内存在函数体结束时被自动销毁。
(3) 使用 free 或 delete 释放了内存后,没有将指针设置为 NULL。导致产生“野指针”。


【规则11-1-1】用malloc或new申请内存之后,应该立即检查指针值是否为NULL。 防止使用指针值为 NULL 的内存。
说明:对嵌入式系统,通常内存是有限的,内存的申请可能会失败,如果不检查就对该指针进行操作,可能出现异常,而且这种异常不是每次都出现,比较难定位。

【规则 11-1-2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。

【规则 11-1-3】避免数组或指针的下标越界,特别要当心发生“多 1”或者“少 1” 操作。
说明:内存操作主要是指对数组、指针、内存地址等的操作,内存操作越界是软件系统主要错误之一,后果往往非常严重,所以当我们进行这些操作时一定要仔细。

示例:C语言中字符型变量,打效值范围为-128127。故以下表达式的计算存在一定风险。
char ch = 127;
int sum = 200;
ch += 1; // 127为ch的边界值,再加将使ch上溢到128,而不是128 sum += ch; //故sum的结果不是328,而是72。

坚持下列措施可以避免内存越界:

• 数组的大小要考虑最大情况,避免数组分配空间不够。
• 避免使用危险函数sprintf/vsprintf/strcpy/strcat/gets操作字符中,使用相对安全的函数 snprintf/strncpy/strncat/fgets代替。
• 使用memcpy/memset时一定要确保长度不要越界
• 字符串考虑最后的’ \0’,确保所有字符串是以’ \0’结束,指针加减操作时,考虑指针类型长度
• 数组下标进行检查
• 使用时sizeof或者strlen计算结构/字符串长度,避免手工计算。

延伸阅读材料:《公司常见软件编程低级错误:内存越界.ppt》

【规则 11-1-4】动态内存的申请与释放必须配对,防止内存泄漏。
坚持下列措施可以避免内存泄漏:

• 异常出口处检查内存、定时器/文件句柄/Socket/队列/信号量/GUI等资源是否全部释放
• 删除结构指针时,必须从底层向上层顺序删除
• 使用指针数组时,确保在释放数组时,数组中的每个元指针是否已经提前被释放了
• 避免出现重复分配内存
• 小心使用有return、break语句的宏,确保前面资源已经释放
• 检查队列中毎个成员是否释放

延伸阅读材料:《公司常见软件编程低级错误:内存泄漏.ppt》

【规则 11-1-5】用 free 或 delete 释放了内存之后,立即将指针设置为 NULL,防止产
生“野指针”。

说明:指针释放后,该指针可能还是指向原有的内存块,可能不是,变成一个野指针,一般 用户不会对它再操作,但用户失误情况下对它的操作可能导致程序崩溃。

坚持下列措施可以避免引用已经释放的内存空间:

• 内存释放后,把指针置为NULL;
• 使用内存指针前进行非空判断。
• 耦合度较强的模块互相调用时,一定要仔细考虑其调用关系,防止已经删除的对象被再次使用。
• 避免操作己发送消息的内存。
• 自动存储对象的地址不应赋值给其他的在第一个对象己经停止存在后仍然保持的对象(具有更大作用域的对象或者静态对象或者从一个函数返回的对象)

延伸阅读材料:《公司常见软件编程低级错误:野指针.ppt》

补充11-1-6 不使用 realloc( )
说明:调用 realloc 对一个内存块进行扩展,导致原来的内容发生了存储位置的变化, realloc 函数既要调用 free,又要调用 malloc。执行时究竟调用哪个函数,取决于是要缩小还是扩大相应内存块的大小。


11.2 指针使用

11.2.1 指针与数组的对比

C++/C 程序中,指针和数组在不少地方可以相互替换着用,让人产生一种错觉,以 为两者是等价的。
数组要么在静态存储区被创建(如全局数组),要么在栈上被创建。数组名对应着(而 不是指向)一块内存,其地址与容量在生命期内保持不变,只有数组的内容可以改变。 指针可以随时指向任意类型的内存块,它的特征是“可变”,所以我们常用指针来操作动态内存。指针远比数组灵活,但也更危险。

11.2.1.1 修改内容

示例 7-3-1 中,字符数组 a 的容量是 6 个字符,其内容为 hello\0。a 的内容可以改变,
如a[0]= ‘X’。指针p指向常量字符串“world”(位于静态存储区,内容为world\0),常量字符串的内容是不可以被修改的从语法上看,编译器并不觉得语句 p[0]= ‘X’有什么 不妥,但是该语句企图修改常量字符串的内容而导致运行错误。

示例 7-3-1 修改数组和指针的内容

char a[] = “hello”; 
a[0] =X;
cout << a << endl; 
char *p = “world”; 	// 注意 p 指向常量字符串
p[0] =X;			// 编译器不能发现该错误
cout << p << endl;
 
11.2.1.2 内容复制与比较

不能对数组名进行直接复制与比较。示例 7-3-2 中,若想把数组 a 的内容复制给数
组 b,不能用语句 b = a ,否则将产生编译错误。应该用标准库函数 strcpy 进行复制。 同理,比较 b 和 a 的内容是否相同,不能用 if(b == a) 来判断,应该用标准库函数 strcmp 进行比较。语句 p = a 并不能把 a 的内容复制指针 p,而是把 a 的地址赋给了 p。要想复制 a 的内容,可以先用库函数malloc为p申请一块容量为strlen(a)+1个字符的内存,再用 strcpy 进行字符串复制。同理,语句 if(p == a) 比较的不是内容而是地址,应该用库函 数 strcmp 来比较。

示例 7-3-2 数组和指针的内容复制与比较
// 数组...
char a[] = "hello";
char b[10];
strcpy(b, a); // 不能用 b = a; 
if(strcmp(b, a) == 0) // 不能用 if (b == a)
...

// 指针...
char a[] = "hello";
int len = strlen(a);
char *p = (char *)malloc(sizeof(char)*(len+1)); 
strcpy(p,a); // 不要用 p = a; 
if(strcmp(p, a) == 0) // 不要用 if (p == a)
...
11.2.1.3 计算内存容量

用运算符 sizeof 可以计算出数组的容量(字节数)。示例 7-3-3(a)中,sizeof(a)
的值是 12(注意别忘了’\0’)。指针 p 指向 a,但是 sizeof ( p ) 的值却是 4。这是因为 sizeof ( p)得到的是一个指针变量的字节数,相当于 sizeof(char*),而不是 p 所指的内 存容量。C++/C 语言没有办法知道指针所指的内存容量,除非在申请内存时记住它。
注意当数组作为函数的参数进行传递时,该数组自动退化为同类型的指针。
示例 7-3-3(b)中,不论数组 a 的容量是多少,sizeof(a)始终等于 sizeof(char *)。

示例 7-3-3(a) 计算数组和指针的内存容量

char a[] = "hello world";
char*p =a;
cout<< sizeof(a) << endl; // 12 字节 
cout<< sizeof(p) << endl; // 4 字节

示例 7-3-3(b) 数组退化为指针
void Func(char a[100]) {
	cout<< sizeof(a) << endl; // 4 字节而不是 100 字节 
}
11.2.2 指针参数是如何传递内存的?

如果函数的参数是一个指针,不要指望用该指针去申请动态内存。示例 7-4-1 中, Test 函数的语句 GetMemory(str, 200)并没有使 str 获得期望的内存,str 依旧是 NULL, 为什么?

示例 7-4-1 试图用指针参数申请动态内存

void GetMemory(char *p, int num) 
{
	p = (char *)malloc(sizeof(char) * num); 
}
void Test(void) 
{
	char *str = NULL;
	GetMemory(str, 100); // str 仍然为 NULL strcpy(str, "hello"); // 运行错误
}

毛病出在函数 GetMemory 中。编译器总是要为函数的每个参数制作临时副本,指针 参数 p 的副本是 _p,编译器使 _p = p。如果函数体内的程序修改了_p 的内容,就导致 参数 p 的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中,_p 申请 了新的内存,只是把_p 所指的内存地址改变了,但是 p 丝毫未变。所以函数 GetMemory 并不能输出任何东西。事实上,每执行一次 GetMemory 就会泄露一块内存,因为没有用 free 释放内存。

如果非得要用指针参数去申请内存,那么应该改用“指向指针的指针”,见示例 7-4-2。

示例 7-4-2 用指向指针的指针申请动态内存

void GetMemory2(char **p, int num) 
{
   *p = (char *)malloc(sizeof(char) * num); 
}

void Test2(void) 
{
   char *str = NULL;
   GetMemory2(&str, 100); // 注意参数是 &str,而不是 str strcpy(str, "hello");
   cout<< str << endl;
   free(str);
}

由于“指向指针的指针”这个概念不容易理解,我们可以用函数返回值来传递动态
内存。这种方法更加简单,见示例 7-4-3。

示例 7-4-3 用函数返回值来传递动态内存

char *GetMemory3(int num) 
{
	char *p = (char *)malloc(sizeof(char) * num);
	return p; 
}

void Test3(void) 
{
	char *str = NULL;
	str = GetMemory3(100); 
	strcpy(str, "hello"); 
	cout<< str << endl; 
	free(str);
}

拓展:char* p与char p[]的比较

11.2.3 free 和 delete 把指针怎么啦?

别看 free 和 delete 的名字恶狠狠的(尤其是 delete),它们只是把指针所指的内存给释放掉,但并没有把指针本身干掉。用调试器跟踪示例 7-5,发现指针 p 被 free 以后其地址仍然不变(非 NULL),只是 该地址对应的内存是垃圾,p 成了“野指针”。如果此时不把 p 设置为 NULL,会让人误 以为 p 是个合法的指针。如果程序比较长,我们有时记不住 p 所指的内存是否已经被释放,在继续使用 p 之 前,通常会用语句 if (p != NULL)进行防错处理。很遗憾,此时 if 语句起不到防错作用, 因为即便 p 不是 NULL 指针,它也不指向合法的内存块。

示例 7-5 p 成为野指针
char *p = (char *) malloc(100);
strcpy(p, “hello”);
free(p); // p 所指的内存被释放,但是 p 所指的地址仍然不变 
...
if(p != NULL) // 没有起到防错作用
{
	strcpy(p, “world”); // 出错 
}
11.2.4 动态内存会被自动释放吗?

函数体内的局部变量在函数结束时自动消亡。很多人误以为示例 7-6 是正确的。理
由是 p 是局部的指针变量,它消亡的时候会让它所指的动态内存一起完蛋。这是错觉!

void Func(void) 
{
	char *p = (char *) malloc(100); // 动态内存会自动释放吗? 
}

我们发现指针有一些“似是而非”的特征:
(1)指针消亡了,并不表示它所指的内存会被自动释放。
(2)内存被释放了,并不表示指针会消亡或者成了 NULL 指针。

这表明释放内存并不是一件可以草率对待的事。也许有人不服气,一定要找出可以草率行事的理由:如果程序终止了运行,一切指针都会消亡,动态内存会被操作系统回收。既然如此在程序临终前,就可以不必释放内存、不必将指针设置为 NULL 了。终于可以偷懒而不会发生错误了吧?想得美。如果别人把那段程序取出来用到其它地方怎么办?

11.2.5 内存耗尽怎么办?

如果在申请动态内存时找不到足够大的内存块,malloc 和 new 将返回 NULL 指针, 宣告内存申请失败。通常有三种方式处理“内存耗尽”问题。

(1)判断指针是否为 NULL,如果是则马上用 return 语句终止本函数。例如:
void Func(void) 
{
	A *a=newA; 
	if(a == NULL) 
	{
	return; 
	}
...
}
(2)判断指针是否为 NULL,如果是则马上用 exit(1)终止整个程序的运行。例如: 
void Func(void)
{
	A *a=newA;
	if(a == NULL) 
	{
		cout << “Memory Exhausted” << endl;
		exit(1); 
	}
...
}
(3)new 和 malloc 设置异常处理函数。例如 Visual C++可以用_set_new_hander 函数
为 new 设置用户自己定义的异常处理函数,也可以让 malloc 享用与 new 相同的异常处理函数。详细内容请参考 C++使用手册。

上述(1)(2)方式使用最普遍。如果一个函数内有多处需要申请动态内存,那么方 式(1)就显得力不从心(释放内存很麻烦),应该用方式(2)来处理。很多人不忍心用 exit(1),问:“不编写出错处理程序,让操作系统自己解决行不行?”不行。如果发生“内存耗尽”这样的事情,一般说来应用程序已经无药可救。如果 不用 exit(1) 把坏程序杀死,它可能会害死操作系统。道理如同:如果不把歹徒击毙,歹徒在老死之前会犯下更多的罪。

11.2.6 malloc/free 的使用要点

函数 malloc 的原型如下:

void * malloc(size_t size);

用 malloc 申请一块长度为 length 的整数类型的内存,程序如下:

int *p = (int *) malloc(sizeof(int) * length);

我们应当把注意力集中在两个要素上:“类型转换”和“sizeof”。
malloc 返回值的类型是 void *,所以在调用 malloc 时要显式地进行类型转换,将
void * 转换成所需要的指针类型。
malloc 函数本身并不识别要申请的内存是什么类型,它只关心内存的总字节数。我
们通常记不住 int, float 等数据类型的变量的确切字节数。例如 int 变量在 16 位系统 下是 2 个字节,在 32 位下是 4 个字节;而 float 变量在 16 位系统下是 4 个字节,在 32 位下也是 4 个字节。最好用以下程序作一次测试:

cout << sizeof(char) << endl;
cout << sizeof(int) << endl;
cout << sizeof(unsigned int) << endl; 
cout << sizeof(long) << endl;
cout << sizeof(unsigned long) << endl; 
cout << sizeof(float) << endl;
cout << sizeof(double) << endl;
cout << sizeof(void *) << endl;

在 malloc 的“()”中使用 sizeof 运算符是良好的风格,但要当心有时我们会昏了头,写出 p = malloc(sizeof( p ))这样的程序来。
函数 free 的原型如下:

void free( void * memblock );

为什么 free 函数不象 malloc 函数那样复杂呢?这是因为指针 p 的类型以及它所指的内存的容量事先都是知道的,语句 free§能正确地释放内存。如果 p 是 NULL 指针, 那么 free 对 p 无论操作多少次都不会出问题。如果 p 不是 NULL 指针,那么 free 对 p 连续操作两次就会导致程序运行错误。

11.2.7 new/delete 的使用要点

运算符 new 使用起来要比函数 malloc 简单得多,
例如:

int *p1 = (int *)malloc(sizeof(int) * length); 
int *p2 = new int[length];

这是因为 new 内置了 sizeof、类型转换和类型安全检查功能。对于非内部数据类型 的对象而言,new 在创建动态对象的同时完成了初始化工作。如果对象有多个构造函数, 那么 new 的语句也可以有多种形式。例如

class Obj 
{
public :
	Obj(void); // 无参数的构造函数
	Obj(int x);// 带一个参数的构造函数
...
}

void Test(void) {
	Obj *a = new Obj;
	Obj *b = new Obj(1); // 初值为 1 ...
	delete a;
	delete b;
}

如果用 new 创建对象数组,那么只能使用对象的无参数构造函数。例如

Obj *objects = new Obj[100]; // 创建 100 个动态对象 

不能写成

Obj *objects=newObj[100](1);//创建100个动态对象的同时赋初值1 

在用 delete 释放对象数组时,留意不要丢了符号‘[]’。
例如

delete []objects; // 正确的用法
delete objects; // 错误的用法

后者相当于 delete objects[0],漏掉了另外 99 个对象。

11.2.8 智能指针:任何情况不使用auto_ptr。

通常情况,scoped_ptr可以完全胜任。scoped_ptr禁止用户拷贝构造和赋值。

#include <boost/scoped_ptr.hpp>
scoped_ptr<A> a(new(A));
scoped_ptr<A> a(new(a));//拷贝构造是私有的,禁止拷贝构造
scoped_ptr<A> b;
b=a;//=运算符是私有的,禁止赋值

(来自:GOOGLE C++编程风格指南 智能指针和其他C++特性 1)
from htw

【 规则11-2-1】 指针类型变量必须初始化为 NULL
【规则11-2-2】 指针不要进行复杂的逻辑或算术操作
说明:指针加1的偏移,通常由指针的类型确定,如果通过复杂的逻辑或算术操作,则指针
的位置就很难确定。
【规则11-2-3 】如果指针类型明确不会改变,应该强制为 const 类型的指针,以加强编译器的检查
说明:可以防止不必要的类型转换错误。
【规则11-2-4】 减少指针和数据类型的强制类型转化


11.3 类和函数

11.3.1 在编写派生类的赋值函数时,注意不要忘记对基类的成员变量重新赋值
说明:除非在派生类中调用基类的赋值函数,否则基类变量不会自动被赋值。

正例:
class CBase 
{
public:
	...
	CBase & operate = (const CBase &other); // 类 CBase 的赋值函数 
private:
	int m_iLength; 
	int m_iWidth; 
	int m_iHeigth;
};

class CDerived : public CBase {
public:
	...
	CDerived & operate = (const CDerived &other); // 类 CDerived 的赋值函
private:
	int m_iLength; 
	int m_iWidth; 
	int m_iHeigth;
};

CDerived & CDerived::operate = (const CDerived &other) 
{
	if (this == &other)  //(1)检查自赋值
	{
		return *this; 
	}
	CBase::operate =(other);//(2)对基类的数据成员重新赋值 
							//因为不能直接操作私有数据成员 
							//(3)对派生类的数据成员赋值
	m_iLength = other.m_iLength; 
	m_iWidth = other.m_iWidth; 
	m_iHeigth = other.m_iHeigth;
	return *this; 			//(4)返回本对象的引用 
}

11.3.2 构造函数应完成简单有效的功能,不应完成复杂的运算和大量的内存管理
说明:如果该类有相当多的初始化工作,应生成专门的 Init(…)函数,不能完全在构造函数中进行,因为构造函数没有返回值,不能确定初始化是否成功。

11.3.3 正确处理拷贝构造函数与赋值函数
说明:由于并非所有的对象都会使用拷贝构造函数和赋值函数,程序员可能对这两个函数有些轻视。如果不主动编写拷贝构造函数和赋值函数,编译器将以“位拷贝”的方式自动生成缺省的函数。倘若类中含有指针变量,那么这两个缺省的函数就隐含了错误。

反例:
class CTest 
{
public:
	CTest(const char* lpszStr = NULL); 
	CTest ::~CTest();
protected:
	char* m_pData; // 有指针成员变量
};

// 构造函数实现
CTest ::CTest(const char* lpszStr = NULL): m_pData(NULL) 
{
	if (lpszStr != NULL) 
	{
		m_pData = new char[strlen(lpszStr)+1]; 
		if (m_pData != NULL)
		{
			strcpy(m_pData, lpszStr); 
		}
	} 
}

// 析构函数实现 
CTest ::~CTest()
{
	if (m_pData != NULL) 
	{
		delete m_pData;
		m_pData = NULL; 
	}
} 

int TestFun(void) 
{
	CTest* pA = new CTest("test string!"); 
	CTest B;
	if (pA != NULL) 
	{
		B = *pA; ......
		// pA->m_pData 和 B.m_pData 指向同一块内存
		delete pA; // pA->m_pData 被释放 
	}
	return 0; //函数返回, B 调用析构函数,释放 B.m_pData 导致错误! 
}

11.3.4 过程/函数中申请的(为打开文件而使用的)文件句柄,在过程/函数退出 之前要关闭,除非要把这个句柄传递给其它函数使用

11.3.5 内联函数 (inline)
说明:

  1. 当函数只有 10 行甚至更少时才建议将其定义为内联函数(inline)。
  2. 内联那些包含循环或 switch 语句的函数是得不偿失的,除非在大多数情况下, 这些循环或 switch 语句从不执行。
  3. 虚函数和递归函数即使被声明为内联的也不一定就是内联函数。通常,递归函数 不应该被声明为内联的(注:递归调用堆栈的展开并不像循环那么简单,比如递 归层数在编译时可能是未知的,大多数编译器都不支持内联递归函数)。

原则11. 2 要时刻注意易混淆的操作符。
说明:包括易混淆和的易用错操作符
1、易混淆的操作符
C语言中有些操作符很容易混淆,编码时要非常小心。

赋位操作符 “=” 		逻辑操作符“==” 
关系操作符 “<” 		位操作符 “<<" 
关系操作符 “>”		位操作符 “>>”
逻辑操作符 “||” 		位操作符 "|" 
逻辑操作符 “&&” 		位操作符 "&"
逻辑操作符 "!"		位操作符 "~"

2、易用错的操作符
(1) 除操作符" / "
当除操作符" / “的运算量是整型量时,运算结果也是整型。
(2) 求余操作符”%"
求余操作符"%"的运算量只能是整型。

5.0%2 是错误的

(3)自加、自减操作符“++”、“- -’’

//示例1
k = 5;
x = k++;
执行后,x = 5, k = 6 

//示例2
k = 5;
x = ++k;
执行后,x = 6, k = 6 

//示例3
k = 5;
x = k--; 
执行后,x = 5, k = 4

//示例4
k = 5;
x = k; 
执行后,x = 4, k = 4

建议6. 3 不要滥用goto语句。


11.4 安全性

代码的安全漏洞大都是由代码缺陷导致,但不是所有代码缺陷都有安全风险。理解安全漏洞产生的原理和如何进行安全编码是减少软件安全问题最直接有效的办法。

原则13.1对用户输入进行检查。
说明:不能假定用户输入都是合法的,因为难以保证不存在恶意用户,即使是合法用户也可能山于误用误操作而产生非法输入。用户输入通常需要经过检验以保证安全,特别是以下场景:

• 用户输入作为循环条件
• 用户输入作为数组下标
• 用户输入作为内存分配的尺寸参数
• 用户输入作为格式化字符串
•用户输入作为业务数据(如作为命令执行参数、拼装sql语句、以特定格式持久化)

这些情况下如果不对用户数据做合法性验证,很可能导致DOS、内存越界、格式化字符串漏洞、命令注入、SQL注入、缓冲区溢出、数据破坏等问题。
可采取以下措施对用户输入检査:

• 用户输入作为数值的,做数值范围检查
• 用户输入是字符串的,检査字符串长度
• 用户输入作为格式化字符串的,检查关键字“%”
•用户输入作为业务数裾,对关键字进行检查、转义

13.1字符串操作安全
规则13.1确保所有字符串是以NULL结束。
说明:C语言中’\0’作为字符串的结束符,即NULL结束符。标准字符中处理函数(如strcpy()、strlen() ) 依赖NULL结束符来确定字符串的长度。没有正确使用NULL结束字符中会导致缓冲区溢出和其它未定义的行为。 为了避免缓冲区溢出,常常会用相对安全的限制字符数量的字符申操作函数代替一些危险函数。如:

• 用 strncpy ()代替 strcpy ()
• 用 strncat ()代替 strcat ()
• 用 snprintf()代替 sprintf ()
• 用 fgets ()代替 gets()

这些函数会截断超出指定限制的字符串,但是要注意它们并不能保证目标字符串总是以NULL结尾。如果源字符申的前n个字符中不存在NULL字符,目标字符串就不是以NULL结尾。

示例:
char a[16];
strncpy(a, "0123456789abcdef", sizeof(a))

上述代码存在安全风险:在调用strncpy()后,字符数组a中的字符串是没打NULL结朿符的,也没有空间存放NULL结朿符。

正确写法:
截断字符串,保证字符串以NULL结朿。
char a[16]:
strncpy(a, "0123456789abcdef*, sizeof(a) - 1 ); a [sizeof (a) - 1] = ’ \0;

规则13.2不要将边界不明确的字符串写到固定长度的数组中。
说明:边界不明确的字符申(如来ftgets()、getenv()、scanf()的字符中),长度可能大于目标数组长度,直接拷贝到同定长度的数组中容易导致缓冲区溢出。

示例:
char buff[256]:
char *editor = getenv("EDITOR"); 
if (editor != NULL)
{
	strcpy(buff, editor):
} 

上述代码读取环境变量"EDITOR"的位,如果成功则拷贝到缓冲区buff中。而从环境变量获取到的字符串长度是不确定的,把它们拷贝到固定长度的数组中很可能导致缓冲区溢出。

正确写法:计算字符中的实际长度,使用malloc分配指定长度的内存
char *buff;
char *editor = getenv("EDITOR"); 
if (editor != NULL)
{
	buff = malloc(strlen(editor) + 1): 
	if (buff != NULL)
	{
		strcpy (buff, editor):
	} 
}

13.2整数安全
C99标准定义了整型提升(integer promotions)、整型转换级别(integer conversion rank)以及普通算术转换(usual arithmetic conversions)的整型操作。不过这些操作实际上也带来了安全风 险。

规则13. 3避免整数溢出。
说明:当一个整数被增加超过其最大值时会发生整数上溢,被减小小于其最小位时会发生整数下溢。 带符号和无符号的数都有可能发生溢出。

示例1:有符号和无符号整数的上溢和下溢 
int i;
unsigned int j;
i = INT_MAX; // 2,147,483,647
i++;
printf(i = %d\n", i); // i= -2,147,483,648 

j = UINT_MAX; // 4,294,967,295;
j++;
printf(j = %u\n", j); // j = 0

i = INT_MIN; // -2,147,483,648;
i--;
printf(i = %d\n", i); // i = 2,147,483,647

j = 0; 
j--;
printf("j = %u\n", j); // j = 4,294,967,295 
示例2:整数下溢导致报文长度异常
/*报文长度减去FSM头的长度*/ 
unsigned int length;
length -= FSM_HDRLEN :

处理过短报文时,length的长度可能小于FSM HDKLEN,减法的结果小于。由于length是无符号数,结果返回了一个很大的数。

正确写法:增加长度检査
if (length < ESM_11DRLEN ) {
	return V0S_ERR(); 
}
length -= FSM_HDRLEN ;

【规则 11-1-4】时刻注意表达式是否会上溢、下溢。

示例:如下程序将造成变量下溢
unsigned char size :
while (size— >= 0) // 将出现下溢 
{
... // program code
}

//当size等于0时,再减不会小于0,而是OxFF,故程序是一个死循环。应如下修改。 
char size; // 从unsigned char 改为char
while (size— >= 0) 
{
... // program code
}

规则13. 4避免符号错误。
说明:有时从带符号整型转换到无符号整型会发生符号错误,符号错误并不丢失数据,但数据失去了原来的含义。
带符号的整型转换到无符号整型,最高位(high-order bit)会丧失其作为符号位的功能。如果该带符号整数的位非负,那么转换后值不变;如果该带符号整数的位为负,那么转换后的结果通常是一个非常大的正数。

示例:符号错误绕过长度检查
#define BUF_SIZE 10
int main(int argc, char* argv[])
{
	int length;
	char buf[BUF_S1ZE]; 
	if (argc != 3)
	{
		return -1;
	}
	length = atoi(argv[1]); //如果atoi返回的长度为负数
	if (length < BUF_SIZE) // len为负数,长度检査无效 
	{
		memcpy (buf, argv[2], length); /*带符号的len被转换为size_t类型的无符号整数,负值被解释为一个极大的正整数。memcpy()调用时引发buf缓冲区溢出*/
		printf (*Data copied\n*); 
	}
	else
	{
		printf("Too many data\n"); 
	}
} 
正确写法1:将len声明为无符号整型
#define BUF_SIZE 10
int main (int argc, char* argv口)
{
	unsigned int length;
	char buf[BUF_SIZE]; 
	if (argc != 3)
	{
			return -1;
	}
	length = atoi(argv[1]);
	if (length < BUF_S1ZE) 
	{
		memcpy(buf, argv[2], length):
		printf("Data copied\n"): 
	 }
	else
	{
		printf(*Too much data\n*);
	}
	return 0;
} 
正确写法2:增加对len的更有效的范围校验
#define BUF_SIZE 10
int main(int argc, char* argv[])
{
	int length;
	char buf[BUF_SIZE]: 
	if (argc != 3)
	{
		return -1:
	}
	 length = atoi(argv[1]):
	if ((length > 0) && (length < BUF_SIZE)) 
	{
		memcpy(buf, argv[2], length);
		printf("Data copied\n"); 
	}
	else
		printf(*Too much data\n*); }
	return 0; 
}

规则13.5:避免截断错误。
说明:将一个较大整型转换为较小整型,并且该数的原位超出较小类型的表示范围,就会发生截断错误,原位的低位被保留而高位被丢弃。截断错误会引起数据丢失。
使用截断后的变量进行内存操作,很可能会引发问题。

示例:
int main(int argc, char* argv[]) 
{
	unsigned short total = strlen(argv[1]) + strlen(argv[2]) + 1; 
	char* buffer = (char*)malloc(total);
	strcpy(buffer, argv[1]); 
	strcat(buffer, argv[2]);
	free(buffer);
	return 0; 
}

示例代码中total被定义为unsigned short,相对于strlen()的返回值类型size_t (通常为unsigned long)太小。如果攻击者提供的两个入参长度分別为65500和36,unsigned long的65500+36+1会被取模截断,total的最终值是(65500+36+1)%65536 = 1 malloc()只为buff分配了1字节空间,为strcpy() 和strcat()的调用创造了缓冲区溢出的条件。

正确写法:将涉及到计算的变量声明为统一的类型,并检查计算结果。
int main(int argc, char* argv[]) 
{
	size_t total = strlen(argv[1]) + strlen(argv[2]) + 1;
	if ((total <= strlen(argv[1])) || (total <=strlen(argv[2]))) 
	{
		/* handle error */
		return -1; 
	}
	char* buffer = (char*)malloc(total); 
	strcpy(buffer, argv[1]); 
	streat(buffer, argv[2]);
	free(buffer);
	return 0; 
}

在这里插入图片描述
13.3格式化输出安全
规则13.6:确保格式字符和参数匹配。
说明:使用格式化字符串应该小心,确保格式字符和参数之间的匹配,保用数量和数据类型。格式字符和参数之间的不匹配会导致未定义的行为。大多数情况下,不正确的格式化字符串会导致程序异常终止。

示例:
char *error msg = ^Resource not available to user.*; int error_type = 3;
/*格式字和参数的类型不匹配*/
printf(*Error (type %s): %d\n*, error_type, error msg);
/*格式字符和参数的数量不匹配*/
printf(*Error: %s\n*); 

格式化字符串在编码时会大量使用,容易copy-paste省事,这就容易出现不匹配的错误。

规则13. 7避免将用户输入作为格式化字符串的一部分或者全部。
说明:调用格式化I/O函数时,不要直接或者间接将用户输入作为格式化字符串的一部分或者全部。攻击者对一个格式化字符串拥有部分或完全控制,存在以下风险:进程崩溃、査看栈的内容、改写内存、 甚至执行任意代码。

示例1:
char input[1000];
if (fgets(input, sizeof(input) - 1, stdin) == NULL)
{
}
input[sizeof(input)-1] = ’\0; 
printf (input):

上述代码input直接来自用户输入,并作为格式化字符中直接传递给printf()。当用户输入“%s%s%s%s%s%s%s%s%s%s%s%s”,就可能触发无效指针或未映射的地址读取。格式字符%s显示栈上相应参数所指定的地址的内存。这里input被当成格式化字符串,而没有提供参数,因此printf()读取栈中任意内存位置,直到格式字符耗尽或者遇到一个无效指针或未映射地址为止。

正确做法:给printf()传两个参数,第一个参数为"%s",目的是将格式化字符中确定下来:第二个参数为用户输入input。
char input[1000];
if (fgets(input, sizeof(input) - 1, stdin) == NULL)
{
}
input[sizeof(input)-1] = ’\0; 
printf ("%s", input):

13.4文件I/O安全

规则13.8避免使用strlen()计算二进制数据的长度。
说明:strlen()函数用于计算字符中的长度,它返回字符串中第一个NULL结朿符之前的字符的数量。 因此用strlen()处理文件I/O函数读取的内容时要小心,因为这些内容可能是二进制也可能是文本。

示例:
char buf[BUF_SIZE + 1];
if (fgets(buf, sizeof(buf), fp) = NULL) {
	/* handle error*/
}
buf [strlen(buf)1] = '\0' ;

上述代码试图从一个输入行中删除行尾的换行符(\n)。如果buf的第一个字符是NULL, strlen(buf)返冋0,这时对buf进行数组下标为[-1]的访问操作将会越界。

正确做法:在不能确定从文件读取到的数裾的类型时,不要使用依赖NULL结束符的字符中操作函数。
char buf[BUF_SIZE + 1]; 
char *p;
if (fgets(buf, sizeof (buf), fp))
{
	p = strchr (buf, '\n');
	if (p) {
		*p = '\0' ; 
	}
}
else
{
  /*handle error condition*/
}

规则13.9使用int类型变量来接受字符I/O函数的返回值。
说明:字符I/O函数fgetcO、getcO和getchar()都从一个流读取一个字符,并把它以int位的形式返回。如果这个流到达了文件尾或者发生读取错误,函数返回EOF。fputc()、putc()、putchar()和ungetc() 也返回一个字符或EOF。
如果这些I/O函数的返回值需要与EOF进行比较,不要将返回值转换为char类型。因为char是有符号8位的值,int是32位的值。如果getchar ()返回的字符的ASCII位为0xFF,转换为char类型后将被解释为EOF。因为这个值被有符号扩展为0xFFFFFFFF (EOF的值)执行比较。

示例:
char buf[BUF_SIZE]:
char ch;
int i = 0;
while ( (ch = getchar()) != '\n' && ch != EOF )
{
	if ( i < BUF_S1ZE - 1 )
	{
		buf[i++] = ch;
	} 
}
buf[i] = '\0' ; /* terminate NTBS*/ 
正确做法:使用int类型的变量接受getchar ()的返冋值。
char buf[BUF_S1ZE];
int ch;
int i = 0;
while (((ch = getchar()) != '\n') && ch != EOF) 
{
	if (i < BUF_SIZE - 1)
	{
		buf[i++] = ch; 
	}
}
buf[i] = '\0' ; /* terminate NTBS */

对于sizeof (int) = sizeof (char)的平台,用int接收返冋值也可能无与EOF区分,这时要用feof ()和terror ()检测文件尾和文件错误。

13.5其它
规则13.10 防止命令注入。
说明:C99函数system() 通过调用一个系统定义的命令解析器(如UNIX的shell, Windows的CMD. exe) 来执行一个指定的程序/命令。类似的还有POSIX的函数popen()。 如果system()的参数由用户的输入组成,恶意用户可以通过构造恶意输入,改变system()调用的行为。

示例:
system(sprintf(*any_exe %s*, input)):
如果恶意用户输入参数:
happy; useradd attacker
最终shell将字符申“any_exe happy; useradd attacker”解释为两条独立的命令: 
正确做法:使用P0SIX函数execve()代替system()
void secuExec (char *input) 
{
	pid_t pid;
	char *const args[] = {"", input, NULL};
	char *const envs[] = {NULL};
	pid = fork();
	if (pid == -1)
	{
		puts("fork error");
	}
	else if (pid == 0)
	{
		if (execve("Vusr/bin/any_exe", args, envs) == -1)
		{
			puts ("Error executing any_exe");
		}
	}
	return; 
}

Windows环境可能对execve ()的支持不是很完善,建议使用Win32 API CreateProcess ()代替system()

已标记关键词 清除标记
相关推荐
《C和C++安全编码(原书第2版)》是C/C++安全编码领域的权威著作,被视为“标准”参考书,由国际资深软件安全专家撰写,美国CERT主管亲自作序推荐。本书结合国际标准C11和C++11,以及C和C++语言的最新发展,既详细阐述了C/C++语言及其相关库固有的安全问题和陷阱,系统总结了导致软件漏洞的各种常见编码错误,并给出了应对错误的解决方案;又对C/C++软件中常见漏洞的危害、被利用方式、检测方法和应对之道进行了全方位讲解,包含大量编码练习,实践性强。 本文从C和C++语言的各个部分分别介绍了可能导致安全问题的软件漏洞:第1介绍安全术语和概念,并指出为何C和C++程序中存在如此多的漏洞。第2描述C和C++中的字符串操作、常见的安全缺陷以及由此导致的漏洞。第3介绍任意内存写漏洞利用方式,它允许攻击者对内存中任意位置的一个地址进行写操作。第4描述动态内存管理,讨论了动态分配的缓冲区溢出、写入已释放内存,以及重复释放漏洞。第5讨论整数安全问题(即与整数操作相关的安全议题),包括整数溢出、符号错误以及截断错误等。第6描述格式化输出函数的正确和错误的用法,对因这些函数的错误使用所导致的格式字符串和缓冲区溢出漏洞都有讨论。第7重点介绍并发和可能导致死锁、竞争条件和无效的内存访问序列的漏洞。第8描述和文件I/O相关的常见漏洞,包括竞争条件和检查时间与使用时间漏洞。第9推荐一些可以整体改善C/C++应用程序安全性的具体开发实践,这些建议是对每一中用于解决特定漏洞问题的推荐做法的补充。
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页