所谓的数组越界,简单地讲就是指数组下标变量的取值超过了初始定义时的大小,导致对数组元素的访问出现在数组的范围之外,这类错误也是 C 语言程序中最常见的错误之一。
在 C 语言中,数组必须是静态的。换而言之,数组的大小必须在程序运行前就确定下来。由于 C 语言并不具有类似 Java 等语言中现有的静态分析工具的功能,可以对程序中数组下标取值范围进行严格检查,一旦发现数组上溢或下溢,都会因抛出异常而终止程序。也就是说,C 语言并不检验数组边界,数组的两端都有可能越界,从而使其他变量的数据甚至程序代码被破坏。
因此,数组下标的取值范围只能预先推断一个值来确定数组的维数,而检验数组的边界是程序员的职责。
一般情况下,数组的越界错误主要包括两种:数组下标取值越界与指向数组的指针的指向范围越界。
数组下标取值越界
数组下标取值越界主要是指访问数组的时候,下标的取值不在已定义好的数组的取值范围内,而访问的是无法获取的内存地址。例如,对于数组 int a[3],它的下标取值范围是 [0,2](即 a[0]、a[1] 与 a[2])。如果我们的取值不在这个范围内(如 a[3]),就会发生越界错误。示例代码如下所示:
1 int a[3]; 2 int i=0; 3 for(i=0;i<4;i++) 4 { 5 a[i] = i; 6 } 7 for(i=0;i<4;i++) 8 { 9 printf("a[%d]=%d ",i,a[i]); 10 }
很显然,在上面的示例程序中,访问 a[3] 是非法的,将会发生越界错误。因此,我们应该将上面的代码修改成如下形式:
1 int a[3]; 2 int i=0; 3 for(i=0;i<3;i++) 4 { 5 a[i] = i; 6 } 7 for(i=0;i<3;i++) 8 { 9 printf("a[%d]=%d ",i,a[i]); 10 }
指向数组的指针的指向范围越界
指向数组的指针的指向范围越界是指定义数组时会返回一个指向第一个变量的头指针,对这个指针进行加减运算可以向前或向后移动这个指针,进而访问数组中所有的变量。但在移动指针时,如果不注意移动的次数和位置,会使指针指向数组以外的位置,导致数组发生越界错误。下面的示例代码就是移动指针时没有考虑到移动的次数和数组的范围,从而使程序访问了数组以外的存储单元。
1 int i; 2 int *p; 3 int a[5]; 4 /*数组a的头指针赋值给指针p*/ 5 p=a; 6 for(i=0;i<10;i++) 7 { 8 /*指针p指向的变量*/ 9 *p=i+10; 10 /*指针p下一个变量*/ 11 p++; 12 }
在上面的示例代码中,for 循环会使指针 p 向后移动 10 次,并且每次向指针指向的单元赋值。但是,这里数组 a 的下标取值范围是 [0,4](即 a[0]、a[1]、a[2]、a[3] 与 a[4])。因此,后 5 次的操作会对未知的内存区域赋值,而这种向内存未知区域赋值的操作会使系统发生错误。正确的操作应该是指针移动的次数与数组中的变量个数相同,如下面的代码所示:
1 int i; 2 int *p; 3 int a[5]; 4 /*数组a的头指针赋值给指针p*/ 5 p=a; 6 for(i=0;i<5;i++) 7 { 8 /*指针p指向的变量*/ 9 *p=i+10; 10 /*指针p下一个变量*/ 11 p++; 12 }
为了加深大家对数组越界的了解,下面通过一段完整的数组越界示例来演示编程中数组越界将会导致哪些问题。
1 #define PASSWORD "123456" 2 int Test(char *str) 3 { 4 int flag; 5 char buffer[7]; 6 flag=strcmp(str,PASSWORD); 7 strcpy(buffer,str); 8 return flag; 9 } 10 int main(void) 11 { 12 int flag=0; 13 char str[1024]; 14 while(1) 15 { 16 printf("请输入密码: "); 17 scanf("%s",str); 18 flag = Test(str); 19 if(flag) 20 { 21 printf("密码错误! "); 22 } 23 else 24 { 25 printf("密码正确! "); 26 } 27 } 28 return 0; 29 }
上面的示例代码模拟了一个密码验证的例子,它将用户输入的密码与宏定义中的密码“123456”进行比较。很显然,本示例中最大的设计漏洞就在于 Test() 函数中的 strcpy(buffer,str) 调用。
由于程序将用户输入的字符串原封不动地复制到 Test() 函数的数组 char buffer[7] 中。因此,当用户的输入大于 7 个字符的缓冲区尺寸时,就会发生数组越界错误,这也就是大家所谓的缓冲区溢出(Buffer overflow)漏洞。但是要注意,如果这个时候我们根据缓冲区溢出发生的具体情况填充缓冲区,不但可以避免程序崩溃,还会影响到程序的执行流程,甚至会让程序去执行缓冲区里的代码。示例运行结果为:
请输入密码:12345
密码错误!
请输入密码:123456
密码正确!
请输入密码:1234567
密码正确!
请输入密码:aaaaaaa
密码正确!
请输入密码:0123456
密码错误!
请输入密码:
在示例代码中,flag 变量实际上是一个标志变量,其值将决定着程序是进入“密码错误”的流程(非 0)还是“密码正确”的流程(0)。当我们输入错误的字符串“1234567”或者“aaaaaaa”,程序也都会输出“密码正确”。但在输入“0123456”的时候,程序却输出“密码错误”,这究竟是为什么呢?
其实,原因很简单。当调用 Test() 函数时,系统将会给它分配一片连续的内存空间,而变量 char buffer[7] 与 int flag 将会紧挨着进行存储,用户输入的字符串将会被复制进 buffer[7] 中。如果这个时候,我们输入的字符串数量超过 6 个(注意,有字符串截断符也算一个),那么超出的部分将破坏掉与它紧邻着的 flag 变量的内容。
当输入的密码不是宏定义的“123456”时,字符串比较将返回 1 或 -1。我们都知道,内存中的数据按照 4 字节(DWORD)逆序存储,所以当 flag 为 1 时,在内存中存储的是 0x01000000。如果我们输入包含 7 个字符的错误密码,如“aaaaaaa”,那么字符串截断符 0x00 将写入 flag 变量,这样溢出数组的一个字节 0x00 将恰好把逆序存放的 flag 变量改为 0x00000000。在函数返回后,一旦 main 函数的 flag 为 0,就会输出“密码正确”。这样,我们就用错误的密码得到了正确密码的运行效果。
而对于“0123456”,因为在进行字符串的大小比较时,它小于“123456”,flag的值是 -1,在内存中将按照补码存放负数,所以实际存储的不是 0x01000000 而是 0xffffffff。那么字符串截断后符 0x00 淹没后,变成 0x00ffffff,还是非 0,所以没有进入正确分支。
其实,本示例只是用一个字节淹没了邻接变量,导致程序进入密码正确的处理流程,使设计的验证功能失效。
尽量显式地指定数组的边界
在 C 语言中,为了提高运行效率,给程序员更大的空间,为指针操作带来更多的方便,C 语言内部本身不检查数组下标表达式的取值是否在合法范围内,也不检查指向数组元素的指针是不是移出了数组的合法区域。因此,在编程中使用数组时就必须格外谨慎,在对数组进行读写操作时都应当进行相应的检查,以免对数组的操作超过数组的边界,从而发生缓冲区溢出漏洞。
要避免程序因数组越界所发生的错误,首先就需要从数组的边界定义开始。尽量显式地指定数组的边界,即使它已经由初始化值列表隐式指定。示例代码如下所示:
1 int a[]={1,2,3,4,5,6,7,8,9,10};
很显然,对于上面的数组 a[],虽然编译器可以根据始化值列表来计算出数组的长度。但是,如果我们显式地指定该数组的长度,例如:
1 int a[10]={1,2,3,4,5,6,7,8,9,10};
它不仅使程序具有更好的可读性,并且大多数编译器在数组长度小于初始化值列表的长度时还会发生相应警告。
当然,也可以使用宏的形式来显式指定数组的边界(实际上,这也是最常用的指定方法),如下面的代码所示:
1 #define MAX 10 2 … 3 int a[MAX]={1,2,3,4,5,6,7,8,9,10};
除此之外,在 C99 标准中,还允许我们使用单个指示符为数组的两段“分配”空间,如下面的代码所示:
1 int a[MAX]={1,2,3,4,5,[MAX-5]=6,7,8,9,10};
在上面的 a[MAX] 数组中,如果 MAX 大于 10,数组中间将用 0 值元素进行填充(填充的个数为 MAX-10,并从 a[5] 开始进行 0 值填充);如果 MAX 小于 10,“[MAX-5]”之前的 5 个元素(1,2,3,4,5)中将有几个被“[MAX-5]”之后的 5 个元素(6,7,8,9,10)所覆盖,示例代码如下所示:
1 #define MAX 10 2 #define MAX1 15 3 #define MAX2 6 4 int main(void) 5 { 6 int a[MAX]={1,2,3,4,5,[MAX-5]=6,7,8,9,10}; 7 int b[MAX1]={1,2,3,4,5,[MAX1-5]=6,7,8,9,10}; 8 int c[MAX2]={1,2,3,4,5,[MAX2-5]=6,7,8,9,10}; 9 int i=0; 10 int j=0; 11 int z=0; 12 printf("a[MAX]: "); 13 for(i=0;i<MAX;i++) 14 { 15 printf("a[%d]=%d ",i,a[i]); 16 } 17 printf(" b[MAX1]: "); 18 for(j=0;j<MAX1;j++) 19 { 20 printf("b[%d]=%d ",j,b[j]); 21 } 22 printf(" c[MAX2]: "); 23 for(z=0;z<MAX2;z++) 24 { 25 printf("c[%d]=%d ",z,c[z]); 26 } 27 printf(" "); 28 return 0; 29 }
运行结果为:
a[MAX]:
a[0]=1 a[1]=2 a[2]=3 a[3]=4 a[4]=5 a[5]=6 a[6]=7 a[7]=8 a[8]=9 a[9]=10
b[MAX1]:
b[0]=1 b[1]=2 b[2]=3 b[3]=4 b[4]=5 b[5]=0 b[6]=0 b[7]=0 b[8]=0 b[9]=0 b[10]=6 b[11]=7 b[12]=8 b[13]=9 b[14]=10
c[MAX2]:
c[0]=1 c[1]=6 c[2]=7 c[3]=8 c[4]=9 c[5]=10
对数组做越界检查,确保索引值位于合法的范围之内
要避免数组越界,除了上面所阐述的显式指定数组的边界之外,还可以在数组使用之前进行越界检查,检查数组的界限和字符串(也以数组的方式存放)的结束,以保证数组索引值位于合法的范围之内。例如,在写处理数组的函数时,一般应该有一个范围参数;在处理字符串时总检查是否遇到空字符‘