【Linux】栈保护 栈溢出 stack smashing detected 定位方法

已于 2023-09-11 09:19:32 修改
阅读量8.7k 收藏 24
点赞数 7
分类专栏： linux内核调试 文章标签： linux gcc/gdb编译调试 stackoverflow stack
于 2020-04-17 17:32:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rentong123/article/details/105584532
版权

栈保护 栈溢出 stack smashing detected 定位方法

一、Linux开发环境

OS：Ubuntu 16.04.1
编译工具：gcc 5.4.0
调试工具：gdb

二、关键词

栈保护
栈溢出
*** stack smashing detected ***
-fstack-protector
-fno-stack-protector

三、背景

gcc提供栈溢出保护机制，即默认编译时-fstack-protector选项为开。
在该保护机制下，如果程序中有栈溢出，会有以下报错信息，程序异常终止：
*** stack smashing detected ***: ./test terminated
Aborted (core dumped)

若要关闭栈溢出保护，在gcc编译选项中增加-fno-stack-protector即可。
关闭后，如果程序中有栈溢出，仍可能会成功执行完，没有任何报错。
但实际上，栈溢出会导致程序中定义的变量被篡改。

如果你的程序出现上面提到的两种异常：变量被篡改、或者栈溢出导致的异常终止，希望本文会对你有帮助。

四、定位分析

1)第一种情况：变量的值被篡改。

a)源代码（可不看）

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "math.h"
#include <ctype.h>

int c2i(char ch)
{
	//如果是数字，则用ascii 减去48
	//isdight 判断数字函数
	if(isdigit(ch))
	{
		return ch-48;
	}
	//判断字母
	if(ch<'A'||(ch>'F'&&ch<'a')||ch>'z')
	{
		return -1;
	}
	//大写字母减去55，小写字母减去87
	if(isalpha(ch))
	{
		return isupper(ch)?ch-55:ch-87;
	}
}

int hex2dec(char *hex)
{
	int len, num,temp,bits,i;
	num = 0;
	len = strlen(hex);
	//printf("len = %d\n",len);
	for(i=0,temp=0;i<len;i++,temp=0)
	{
		//printf("hex = %c\n",hex[i]);
		//printf("num = %d\n",num);
		temp = c2i(*(hex+i));
		//printf("temp = %d\n",temp);
		bits = (len-i-1)*4;
		//printf("bits = %d\n",bits);
		temp = temp << bits;
		//printf("temp = %d\n",temp);
		num = num|temp;
	}
	return num;
}

char* itoa(long int num,char *str,int radix)
{
	char index[] = "0123456789ABCDEF";
	long unsigned unum;
	int i=0,j,k;
	if(radix==10&&num<0)
	{
		unum = (unsigned) -num;
		str[i++] = '-';
	}
	else
		unum = (unsigned)num;
	do
	{
		str[i++] = index[unum%(unsigned)radix];
		unum/=radix;
	}while(unum);
	//printf("str = %s\n",str);
	str[i] = '\0';
	if(str[0]=='-')
	{
		k = 1;
	}
	else
		k = 0;
	for(j = k;j<=(i-1)/2;j++)
	{
		char temp;
		temp = str[j];
		str[j] = str[i-1+k-j];
		str[i-1+k-j] = temp;
	}
	//printf("str = %s\n",str);
	return str;
}

/******************************************************
生成command 的chksum函数
*******************************************************/
char *creatChksum(char *Commandinfo,char* chkstr)
{
	int temp = 0;
	int chksum = 0;
	
	for(int i=1;i<strlen(Commandinfo);i++)
	{
		temp = Commandinfo[i]+temp;
	}
	//printf("creatChksum = %s\n",Commandinfo);
	//printf("creatChksum = %d\n",temp);
	sprintf(chkstr,"%04X",temp);
	return chkstr;
}

double getRandData(int min,int max)
{
      double m1=(double)(rand()%101)/101;                        							  // 计算 0，1之间的随机小数,得到的值域近似为(0,1)
      min++;                                                                            	  //将 区间变为(min+1,max),
      double m2=(double)((rand()%(max-min+1))+min);    										  //计算 min+1,max 之间的随机整数，得到的值域为[min+1,max]
      m2=m2-1;                                                                        		  //令值域为[min,max-1]
      return m1+m2;                                                                			  //返回值域为(min,max),为所求随机浮点数
}

int creatfloatstr(float num,char *str)
{
	
	int rtn = 0;
	long int tempdata;
	float mantissa = 0;
	int stepdata = 0;
	char tempstr[24];
	char mantissastr[24];
	char strstep[9];
	char strsteptemp[9];
	char floatstr[33];
	#if 1
	if(rtn == 0)
	{
		memset(str,'\0',33);
		//printf("%f\n",num);
		if(rtn == 0)
		{
			for(int i=1;i<20;i++)
			{
				num = num/2;
				if(num<2)
				{
					stepdata = i;
					break;
				}
			}
			mantissa = num -1;
			memset(mantissastr,'\0',24);
			long int mantissadata = mantissa*8388608;
			itoa(mantissadata,tempstr,2);
			if(strlen(tempstr)<23)
			{
				int length = 23 -strlen(tempstr);
				for(int i=0;i<length;i++)
				{
					mantissastr[i] = '0';
				}
				strncat(mantissastr,tempstr,23);
			}
			else
			{
				strncpy(mantissastr,tempstr,23);
			}
		}
		if(rtn == 0)
		{
			memset(strsteptemp,'\0',9);
			memset(strstep,'\0',9);
			itoa(stepdata,strsteptemp,2);
			if(strlen(strsteptemp)<8)
			{
				int length = 8 - strlen(strsteptemp);
				for(int i=0;i<length;i++)
				{
					strstep[i] = '0';
				}
				strcat(strstep,strsteptemp);
			}
			else
			{
				strncpy(strstep,strsteptemp,8);
			}
			//printf("strstep = %s\n",strstep);
		}
		if(rtn == 0)
		{
			if(num<0)
			{
				strcat(str,"1");
			}
			else
			{
				strcat(str,"0");
			}
			strcat(str,strstep);
			strcat(str,mantissastr);
			for(int i = 0;i<strlen(str);i++)
			{
				if(str[i] == '1')
				tempdata = tempdata + pow(2,31-i);
			}
			sprintf(str,"%08lX",tempdata);
		}
		//printf("str = %s\n",str);
	}
	#endif
	return rtn;
}

unsigned int virtual_data(char *receivebuf,char *sendbuf)
{
	int rtn = 0;
	int chkNumber = 0;
	char chucksum[5];
	char cid2[3];
	char length[5];
	int datalength=0;
	char *commandinfo;
	char buf[10];
	char data[8];
	int len = strlen(receivebuf);
	
	memset(buf, '\0', 10);
	memcpy(buf, "ABCDEFGH", 8);
	
	printf("------- buf = %s, line[%d]\n", buf, __LINE__);
	
	if(rtn == 0)
	{
		//首先chucksum
		if(rtn == 0)
		{
			//字符串转数字,计算chksum值
			memset(chucksum,'\0',4);
			for(int i = 0;i<4;i++)
			{
				chucksum[i] = receivebuf[len-6+i];
			}
			chucksum[4] = '\0';
			strncpy(chucksum,chucksum,4);
			for(int i = 1;i<len-6;i++)
			{
				chkNumber = chkNumber + receivebuf[i];
				//printf("receivebuf[i]=%c\n",receivebuf[i]);	
			}
			chkNumber = chkNumber%65536;
			chkNumber = ~chkNumber+1+65536;
			
			if(chkNumber != hex2dec(chucksum))
			{
				//printf("chkNumber=%d\n",chkNumber);			
				//printf("hex2dec(chucksum)=%d\n",hex2dec(chucksum));

				rtn = -1;
			}
		}
		//解析设备类型,填充设备数据，主要解析cid2 length commandinfo chucksum
		#if 1
		if(rtn == 0)
		{
			//填充sendbuf 
			strncpy(sendbuf,receivebuf,7);
			memset(cid2,'\0',3);
			*(cid2) = *(receivebuf+7);
			*(cid2+1) = *(receivebuf+8);
			//printf("%s\n",cid2);
			if(strcmp(cid2,"41") == 0)
			{
				//默认数据正常 rtn 赋值00
				strncat(sendbuf,"00",2);
				memset(length,'\0',5);
				//数据为浮点型数据,处理数据长度
				for(int i = 0;i<4;i++)
				{
					length[i] = receivebuf[10+i];
				}
				strncat(sendbuf,length,4);
				length[3] = '\0';
				//printf("length = %s\n",length);
				datalength = hex2dec(length)/2;
				//printf("datalength = %d\n",datalength);
				
				for(int i=0;i<datalength;i++)
				{
					
					memset(data,'\0',9);
					creatfloatstr(getRandData(0,100),data);
					strncat(sendbuf,data,8);
				}
				

				//memset(sendbuf,'\0',200);
				creatChksum(sendbuf,chucksum);
				strncat(sendbuf,chucksum,4);
				strncat(sendbuf,"CR",2);
			}
			if(strcmp(cid2,"42") == 0)
			{
				//默认数据正常 rtn 赋值00
				strncat(sendbuf,"00",2);
				//数据为整型数据,处理数据长度
				for(int i = 0;i<4;i++)
				{
					length[3-i] = receivebuf[13+i];
				}
				strncat(sendbuf,length,4);
				length[3] = '0';
				datalength = hex2dec(length);
				for(int i=0;i<datalength;i++)
				{
					memset(data,'\0',8);
					sprintf(data,"%04X",rand()%101);
					strncat(sendbuf,data,8);
				}
				memset(sendbuf,'\0',4);
				creatChksum(sendbuf,chucksum);
				strncat(sendbuf,chucksum,4);
				strncat(sendbuf,"CR",2);
			}
		}
		#endif
	}	
	
	printf("------- buf = %s, line[%d]\n", buf, __LINE__);
	
	return rtn;
}

int main()
{
	int rtn = 0;
	char *receivebuf = malloc(256*sizeof(char));
	strncpy(receivebuf,"~20012441E00201FD3ACR",32*sizeof(char));
	char sendbuf[200];

	rtn = virtual_data(receivebuf,sendbuf);
	//printf("send=%s\n",sendbuf);
	exit(0);
	return 0;
}

b)编译

gcc -g -o test main.c –lm

c)运行

在这里插入图片描述
发现buf中的数据被篡改！通过阅读程序，buf在virtual_data函数中定义，之后便再无赋值，那么应该 是在两次打印之间被篡改的。像这种情况，首先怀疑的就是发生了内存越界！

d)定位

在这里插入图片描述

e)总结

程序中能明确看到某个变量的值被篡改，这种情况一般定位思路：
使用watch命令观察该变量；
执行c继续运行，程序会停在观察点发生变化的地方；
执行where命令，查看当前的位置，即定位到哪行语句篡改了被观察的变量。

2)第二种情况：程序报”stack smashing detected”然后终止。

a)源代码（可不看）

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "math.h"
#include <ctype.h>

int c2i(char ch)
{
	//如果是数字，则用ascii 减去48
	//isdight 判断数字函数
	if(isdigit(ch))
	{
		return ch-48;
	}
	//判断字母
	if(ch<'A'||(ch>'F'&&ch<'a')||ch>'z')
	{
		return -1;
	}
	//大写字母减去55，小写字母减去87
	if(isalpha(ch))
	{
		return isupper(ch)?ch-55:ch-87;
	}
}

int hex2dec(char *hex)
{
	int len, num,temp,bits,i;
	num = 0;
	len = strlen(hex);
	//printf("len = %d\n",len);
	for(i=0,temp=0;i<len;i++,temp=0)
	{
		//printf("hex = %c\n",hex[i]);
		//printf("num = %d\n",num);
		temp = c2i(*(hex+i));
		//printf("temp = %d\n",temp);
		bits = (len-i-1)*4;
		//printf("bits = %d\n",bits);
		temp = temp << bits;
		//printf("temp = %d\n",temp);
		num = num|temp;
	}
	return num;
}

char* itoa(long int num,char *str,int radix)
{
	char index[] = "0123456789ABCDEF";
	long unsigned unum;
	int i=0,j,k;
	if(radix==10&&num<0)
	{
		unum = (unsigned) -num;
		str[i++] = '-';
	}
	else
		unum = (unsigned)num;
	do
	{
		str[i++] = index[unum%(unsigned)radix];
		unum/=radix;
	}while(unum);
	//printf("str = %s\n",str);
	str[i] = '\0';
	if(str[0]=='-')
	{
		k = 1;
	}
	else
		k = 0;
	for(j = k;j<=(i-1)/2;j++)
	{
		char temp;
		temp = str[j];
		str[j] = str[i-1+k-j];
		str[i-1+k-j] = temp;
	}
	//printf("str = %s\n",str);
	return str;
}

/******************************************************
生成command 的chksum函数
*******************************************************/
char *creatChksum(char *Commandinfo,char* chkstr)
{
	int temp = 0;
	int chksum = 0;
	
	for(int i=1;i<strlen(Commandinfo);i++)
	{
		temp = Commandinfo[i]+temp;
	}
	//printf("creatChksum = %s\n",Commandinfo);
	//printf("creatChksum = %d\n",temp);
	sprintf(chkstr,"%04X",temp);
	return chkstr;
}

double getRandData(int min,int max)
{
      double m1=(double)(rand()%101)/101;                        							  // 计算 0，1之间的随机小数,得到的值域近似为(0,1)
      min++;                                                                            	  //将 区间变为(min+1,max),
      double m2=(double)((rand()%(max-min+1))+min);    										  //计算 min+1,max 之间的随机整数，得到的值域为[min+1,max]
      m2=m2-1;                                                                        		  //令值域为[min,max-1]
      return m1+m2;                                                                			  //返回值域为(min,max),为所求随机浮点数
}

int creatfloatstr(float num,char *str)
{
	
	int rtn = 0;
	long int tempdata;
	float mantissa = 0;
	int stepdata = 0;
	char tempstr[24];
	char mantissastr[24];
	char strstep[9];
	char strsteptemp[9];
	char floatstr[33];
	#if 1
	if(rtn == 0)
	{
		memset(str,'\0',64);
		//printf("%f\n",num);
		if(rtn == 0)
		{
			for(int i=1;i<20;i++)
			{
				num = num/2;
				if(num<2)
				{
					stepdata = i;
					break;
				}
			}
			mantissa = num -1;
			memset(mantissastr,'\0',24);
			long int mantissadata = mantissa*8388608;
			itoa(mantissadata,tempstr,2);
			if(strlen(tempstr)<23)
			{
				int length = 23 -strlen(tempstr);
				for(int i=0;i<length;i++)
				{
					mantissastr[i] = '0';
				}
				strncat(mantissastr,tempstr,23);
			}
			else
			{
				strncpy(mantissastr,tempstr,23);
			}
		}
		if(rtn == 0)
		{
			memset(strsteptemp,'\0',9);
			memset(strstep,'\0',9);
			itoa(stepdata,strsteptemp,2);
			if(strlen(strsteptemp)<8)
			{
				int length = 8 - strlen(strsteptemp);
				for(int i=0;i<length;i++)
				{
					strstep[i] = '0';
				}
				strcat(strstep,strsteptemp);
			}
			else
			{
				strncpy(strstep,strsteptemp,8);
			}
			//printf("strstep = %s\n",strstep);
		}
		if(rtn == 0)
		{
			if(num<0)
			{
				strcat(str,"1");
			}
			else
			{
				strcat(str,"0");
			}
			strcat(str,strstep);
			strcat(str,mantissastr);
			for(int i = 0;i<strlen(str);i++)
			{
				if(str[i] == '1')
				tempdata = tempdata + pow(2,31-i);
			}
			sprintf(str,"%08lX",tempdata);
		}
		//printf("str = %s\n",str);
	}
	#endif
	return rtn;
}

unsigned int virtual_data(char *receivebuf,char *sendbuf)
{
	int rtn = 0;
	int chkNumber = 0;
	char chucksum[5];
	char cid2[3];
	char length[5];
	int datalength=0;
	char *commandinfo;
	char buf[10];
	char data[8];
	int len = strlen(receivebuf);
	
	memset(buf, '\0', 10);
	memcpy(buf, "ABCDEFGH", 8);
	
	//printf("------- buf = %s, line[%d]\n", buf, __LINE__);
	
	if(rtn == 0)
	{
		//首先chucksum
		if(rtn == 0)
		{
			//字符串转数字,计算chksum值
			memset(chucksum,'\0',4);
			for(int i = 0;i<4;i++)
			{
				chucksum[i] = receivebuf[len-6+i];
			}
			chucksum[4] = '\0';
			strncpy(chucksum,chucksum,4);
			for(int i = 1;i<len-6;i++)
			{
				chkNumber = chkNumber + receivebuf[i];
				//printf("receivebuf[i]=%c\n",receivebuf[i]);	
			}
			chkNumber = chkNumber%65536;
			chkNumber = ~chkNumber+1+65536;
			
			if(chkNumber != hex2dec(chucksum))
			{
				//printf("chkNumber=%d\n",chkNumber);			
				//printf("hex2dec(chucksum)=%d\n",hex2dec(chucksum));

				rtn = -1;
			}
		}
		//解析设备类型,填充设备数据，主要解析cid2 length commandinfo chucksum
		#if 1
		if(rtn == 0)
		{
			//填充sendbuf 
			strncpy(sendbuf,receivebuf,7);
			memset(cid2,'\0',3);
			*(cid2) = *(receivebuf+7);
			*(cid2+1) = *(receivebuf+8);
			//printf("%s\n",cid2);
			if(strcmp(cid2,"41") == 0)
			{
				//默认数据正常 rtn 赋值00
				strncat(sendbuf,"00",2);
				memset(length,'\0',5);
				//数据为浮点型数据,处理数据长度
				for(int i = 0;i<4;i++)
				{
					length[i] = receivebuf[10+i];
				}
				strncat(sendbuf,length,4);
				length[3] = '\0';
				//printf("length = %s\n",length);
				datalength = hex2dec(length)/2;
				//printf("datalength = %d\n",datalength);
				
				for(int i=0;i<datalength;i++)
				{
					
					memset(data,'\0',9);
					creatfloatstr(getRandData(0,100),data);
					strncat(sendbuf,data,8);
				}
				

				//memset(sendbuf,'\0',200);
				creatChksum(sendbuf,chucksum);
				strncat(sendbuf,chucksum,4);
				strncat(sendbuf,"CR",2);
			}
			if(strcmp(cid2,"42") == 0)
			{
				//默认数据正常 rtn 赋值00
				strncat(sendbuf,"00",2);
				//数据为整型数据,处理数据长度
				for(int i = 0;i<4;i++)
				{
					length[3-i] = receivebuf[13+i];
				}
				strncat(sendbuf,length,4);
				length[3] = '0';
				datalength = hex2dec(length);
				for(int i=0;i<datalength;i++)
				{
					memset(data,'\0',8);
					sprintf(data,"%04X",rand()%101);
					strncat(sendbuf,data,8);
				}
				memset(sendbuf,'\0',4);
				creatChksum(sendbuf,chucksum);
				strncat(sendbuf,chucksum,4);
				strncat(sendbuf,"CR",2);
			}
		}
		#endif
	}	
	
	//printf("------- buf = %s, line[%d]\n", buf, __LINE__);
	
	return rtn;
}

int main()
{
	int rtn = 0;
	char *receivebuf = malloc(256*sizeof(char));
	strncpy(receivebuf,"~20012441E00201FD3ACR",32*sizeof(char));
	char sendbuf[200];

	rtn = virtual_data(receivebuf,sendbuf);
	//printf("send=%s\n",sendbuf);
	exit(0);
	return 0;
}

b)编译

gcc -g -o test main.c –lm

c)运行

在这里插入图片描述
此种情况看不到程序内部变量是否发生篡改，会直接退出程序，所以不适合用watch。但是又确实发生了栈溢出，在栈保护机制的作用下，程序并不会在执行到导致栈溢出的那行语句时就报错然后终止，而是把子函数全部执行完，再回到main函数中去。但是由于栈已经被破坏，在往main函数跳的时候，就无法获取main函数的栈空间了，所以异常终止。

d)定位

在这里插入图片描述

e)总结

即先看堆栈，大致确定是哪个函数。然后进到该函数中，逐条语句执行、查看堆栈信息，直到看到栈被破坏。
遇到函数调用层次比较多时，效率会比较低，但也算有效。
Joker524_
关注
  • 7
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
*** stack smashing detected *** 是什么意思？怎么破
qd1006739486的博客
11-27 2万+
一、问题来源？这是什么？ 首先这个错误提示是linux上，c/c++程序中linux上运行时出错的问题。 二、这样的崩溃不处理行不行？ 首先，某些测试用例对这样的崩溃不处理是可以完全通过的。但是通常情况下。这种问题必须要处理。否则你的程序移植性很差。 而且你不知道什么时候就会崩溃。 三、什么样的问题会导致这样的崩溃？ 网上一搜一大把，都说访问数组越界，巴拉巴拉。那么很多人都会把重心放在...
stack smashing detected,程序段错误
热门推荐
linengeir的专栏
12-15 5万+
今天在写程序的时候，突然出现＂stack smashing detected＂的错误．用经常用的调试方法，GDB,语句输出等均不能定位问题的出处． 先说解决方案： 出现这个问题的原因是：在程序函数中，数组越界访问，在程序运行时没出现问题，但当函数return的时候就会出现上面的错误． 解决办法是：gdb, where命令定位到出错的函数，然后检查函数中数组的长度，使其满足程序的要求． 参考
143 Linux 系统编程20，stack smashing detected ./main terminated Aborted (core dumped) error 分析和处理
最新发布
hunandede的博客
03-12 612
程序中能明确看到某个变量的值被篡改，这种情况一般定位思路：使用watch命令观察该变量；执行c继续运行，程序会停在观察点发生变化的地方；执行where命令，查看当前的位置，即定位到哪行语句篡改了被观察的变量。即先看堆栈，大致确定是哪个函数。然后进到该函数中，逐条语句执行、查看堆栈信息，直到看到栈被破坏。遇到函数调用层次比较多时，效率会比较低，但也算有效。
tack smashing detected 错误的处理
yugang_123456的博客
04-07 726
分配空间不足引起的错误：‘Stack smashing detected’ 在程序编译的时候，加上一个选项即可："-fno-stack-protector" 举个简单的例子，比如，原来编译时使用的命令为： gcc -o xxxx source.c 则需要改为： gcc -o xxxx "-fno-stack-protector" source.c 如果是通过makefile文件进行编译，除了那个生成最终二进制文件的编译命令之外，记得将其中每个“.o”文件的编译命令中也加上"-fno-st...
stack smashing detected错误解决
Dream home
09-28 2万+
在运行的时候报stack smashing detected错误问题，原因是GCC的一种检测“缓存溢出”的保护机制．当分配的内存不够时，会继续执行；但是在程序结束返回时才出现错误提示 解决办法就是在编译链中加入对该检查的屏蔽 “-fno-stack-protector” 这样就可以避免问题的出现了
嵌入式TCPIP协议栈相关资料.rar_ARM Linux_TCPIP_tcpip stack_协议_协议栈
09-21
内容包括： 嵌入式TCPIP协议栈应用主机端程序（VC6源码）；如何构造嵌入式Linux系统；基于ARM的嵌入式TCPIP协议的实现等
[error]stack smashing detected
Zander0的博客
01-20 6898
运行环境： 程序是在Linux环境中的 qt 运行的。 遇到过两种出错情况：一. 程序运行后中止，出现上述错误。二. 程序在当前Linux版本上编译后可运行，放到其它Linux版本上不能够运行，出现上述错误。简意就是，本Linux系统版本上编译的可执行程序只能在同Linux系统版本运行。 **第一种情况：**出现stack smashing detected，即栈溢出，但不会定位到哪里出现溢出。 1.原因：C语言比较“宽松、灵活，语法检查不严格”，在遇到数组越界、栈溢出等问题时编译时不会报出来，等到程序运行
stack smashing detected（c++报错）
qq_42281655的博客
09-13 3839
由于地址错乱导致的stack smashing detected
stack smashing detected 程序运行时检测到堆栈破坏或溢出
qq_41896869的博客
06-28 2204
堆栈破坏的问题。
stack smashing detected 的处理
Glory的专栏
08-27 1395
栈溢出实际上是一个保护机制，使用gcc来检测缓冲区溢出攻击。   输入的字符串大于边界导致腐败的gcc内置保护金丝雀变量，SIGABRT终止程序。 您可以禁用此保护使用gcc选项  -fno-stack-protector 而编译。 在这种情况下，你会得到一个分割的错，如果你试图访问非法内存位置。当然你也可以检测溢出的角度说，例如使用Valgrind的。
栈求表达式的值Stack-Expr.zip
12-23
栈求表达式的值Stack-Expr.zip
Stack-栈实例
10-23
栈的实现，Stack栈使用符号进出 静态栈，与链表栈的实例
JS栈stack类的实现与使用方法示例
10-17
主要介绍了JS栈stack类的实现与使用方法,结合实例形式分析了栈的原理,以及javascript定义与使用栈的基本操作技巧,需要的朋友可以参考下
gcc-stack-protector机制
飞翔de刺猬
04-16 1万+
GCC “stack smashing detected”机制相信使用C/C++语言开发软件的程序猿们都经历过‘栈溢出’的问题。‘栈溢出’问题通常十分的隐蔽，有的时候问题复现也十分的困难。每当软件出现莫名其妙的问题时，总是有人怀疑是不是栈溢出了，但是问题的排查又十分的困难，所以，‘栈溢出’就是广大C/C++开发者的噩梦。大家不禁要问有没有通用的方法来避免或者来检测’栈溢出‘问题呢？其实，’栈溢出‘问
Linux——stack smashing detected
weixin_43772611的博客
01-28 2230
文章目录前言一、错误类型二、解决总结 前言 本人在Linux平台做智能影音系统项目的时候，出现了一个“栈错误”*** stack smashing detected ***: ./main terminated 通过在其他博主那里发现这个bug出现在哪里 一、错误类型 如图所示： 二、解决 代码如下（示例）： char video_name[100] = {0}; sprintf(video_name, "mplayer -quiet -slave -input file=/tmp/fifo_f..
C语言 *** stack smashing detected *** 问题的解决
HPC&Geophysics攻城狮
11-25 5939
*** stack smashing detected ***: terminated
Stack smashing detected
Stephan14的专栏
02-02 4485
今天写程序时发现一个新的错误：Stack smashing detected，这个错误以前没有遇到，所以先上网查了一下，并记录下来解决这个问题的过程。 首先这个程序的源代码如下，这个程序是用来求解1000以内的素数。 #include #define TRUE '1' #define FALSE '0' int main(int argc, char const *argv[]) {
解决Qt程序出错stack smashing detected，gdb调试总结
有问题或资源连接有缺失的可以私信公众号新潮看世界获取
04-20 1091
上述问题，引出了我们在Qt程序，不仅仅Qt，C/C++程序都是，如果有不知名的错误产生，或者程序内部栈，内存分配之类的问题，可以使用gdb进行调试。栈被破坏的问题，一般出现在函数的变量之中，单一类型的变量比较简单，基本上不会出错，所以一般还是主要查buffer数组之类的地方。项目上有一个Qt程序，之前在arm32位编译器下编译是好好的，运行也非常顺畅，完全没有出现过错误。如果没法用网络，那么，你就只能一步一步从界面，或数据，或日志，最后挂掉前的位置往前推理。操作各项功能，尤其是最后出现死机现象的那一项。
Linux 输出Stack smashing detected
05-05
"Stack smashing detected"是Linux平台的一种运行时错误，表示程序试图写入超出它的分配内存范围的内存区域，导致栈溢出。这种错误通常是由于程序员编写的代码中存在缓冲区溢出、指针错误或格式化字符串漏洞等问题导致的。要解决这个错误，需要检查程序代码中是否存在这些问题，并修复它们。可以使用一些工具，如Valgrind、AddressSanitizer和GDB等，来帮助诊断和调试这种错误。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值