• 【逆向】03-20扩大节 c++代码完成 ；类当作函数参数却调用了析构函数疑难分析

    若要看PE结构操作最新代码，点击主页查看！！

     

    和上一节的代码相比，本文章主要修复了上一篇文章代码中PE类中的Analyze函数，这样不管是Before_Stretch_Data还是Stretch_Data，Shrink_Data，在这个函数中都可以分析出PE结构

    另外新添加了函数Expand_Section函数，可以自动扩大最后一个节，并写入新的文件中，亲测可以使用，程序可以完美运行
    Expand_Section函数的思路就是
     

    扩大节：

    只能扩大最后一个节

    • 1.拉伸到内存

    • 2.分配一块新的空间，SizeOfImage + Ex(扩大出来的空间)

    • 3.将最后一个节的SizeOfRawData和VirtualSize改成N SizeOfRawData=VirtualSize=N N=(原来的SizeOfRawData和VirtualSize两者比较大的那一个内存对齐后的值)+Ex

    • 4.修改SizeOfImage大小 SizeOfImage=SizeOfImage+Ex

     

    期间我遇到一个百思不得其解的问题：
    就是我将一个类作为参数继续函数传值，但是程序运行报错了，但是如果我传的是引用却不会报错。在文章末尾说

    上代码先：
     

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. #include 
    6. using namespace std;
    7.  
    8. int MAX(int a, int b)
    9. {
    10. 	return a >= b ? a : b;
    11. }
    12.  
    13. class Data
    14. {
    15. public:
    16. 	PIMAGE_DOS_HEADER my_dos;//dos头结构
    17. 	PIMAGE_FILE_HEADER my_file;//file结构
    18. 	PIMAGE_OPTIONAL_HEADER32 my_optional;//可选PE头结构
    19. 	PIMAGE_SECTION_HEADER* my_section ;//节表结构
    20.  
    21.  
    22. 	void* Before_Stretch_Data ; //指向拉伸前的内容
    23. 	void* Stretch_Data ; //指向拉伸后的内容
    24. 	void* Shrink_Data ; //指向缩小PE结构的内容
    25.  
    26. 	Data()
    27. 	{
    28. 		my_dos = nullptr;//dos头结构
    29. 		my_file = nullptr;//file结构
    30. 		my_optional = nullptr;//可选PE头结构
    31. 		my_section = nullptr;//节表结构
    32.  
    33.  
    34. 		Before_Stretch_Data = nullptr; //指向拉伸前的内容
    35. 		Stretch_Data = nullptr; //指向拉伸后的内容
    36. 		Shrink_Data = nullptr; //指向缩小PE结构的内容
    37. 	}
    38.  
    39. 	~Data()
    40. 	{
    41. 		if (Before_Stretch_Data != nullptr)
    42. 		{
    43. 			free(Before_Stretch_Data);
    44. 			Before_Stretch_Data = nullptr;
    45. 		}
    46.  
    47. 		if (Stretch_Data != nullptr)
    48. 		{
    49. 			free(Stretch_Data);
    50. 			Stretch_Data = nullptr;
    51. 		}
    52.  
    53. 		if (Shrink_Data != nullptr)
    54. 		{
    55. 			free(Shrink_Data);
    56. 			Shrink_Data = nullptr;
    57. 		}
    58. 	}
    59.  
    60.  
    61. 	void Copy_Before_Strectch_Data(Data my_data); //只深拷贝Before_Strectch_Data
    62. };
    63.  
    64. void Data::Copy_Before_Strectch_Data(Data my_data)
    65. {
    66. 	int size=_msize(my_data.Before_Stretch_Data);
    67. 	memcpy_s(this->Before_Stretch_Data, size, my_data.Before_Stretch_Data, size);
    68. }
    69.  
    70.  
    71.  
    72. class PE
    73. {
    74. public:
    75.  
    76.  
    77.  
    78.  
    79. public:
    80. 	void Readfile(char* filename, Data& my_data);  //读取pe文件
    81.  
    82. 	void Analyze_PE(Data& my_data);  //分析pe结构
    83. 	
    84. 	void Stretch_PE(Data& my_data);  //拉伸pe结构
    85.  
    86. 	void Shrink_PE(Data& my_data); //缩小pe结构
    87.  
    88. 	void New_Section(char* filename,Data& my_data);//新增节，非扩大节，并写入新的exe文件中
    89.  
    90. 	void Expand_Section(Data& my_data, char* filename);  //扩大节
    91.  
    92. 	int Section_Align(int temp,Data& my_data); //返回内存对齐后的大小
    93.  
    94. 	int File_Align(int temp,Data& my_data); //返回文件对齐后的大小
    95.  
    96. 	void Copy_Data(Data& my_data);
    97. };
    98.  
    99. void PE:: Expand_Section(Data& my_data,char* filename)
    100. {
    101. 	this->Stretch_PE(my_data);
    102. 	unsigned Size = 0;//扩大节后新的文件大小
    103. 	Size = my_data.my_optional->ImageBase + Section_Align(MAX(my_data.my_section[0]->SizeOfRawData, my_data.my_section[0]->Misc.VirtualSize),my_data);
    104.  
    105. 	Data Expand_Data;
    106. 	Expand_Data.Stretch_Data= (void*)malloc(Size);
    107. 	memset(Expand_Data.Stretch_Data, 0, Size);
    108. 	memcpy_s(Expand_Data.Stretch_Data, _msize(my_data.Stretch_Data), my_data.Stretch_Data, _msize(my_data.Stretch_Data));
    109.  
    110. 	Analyze_PE(Expand_Data);
    111.  
    112. 	Expand_Data.my_section[my_data.my_file->NumberOfSections - 1]->SizeOfRawData = Section_Align(MAX(my_data.my_section[0]->SizeOfRawData, my_data.my_section[0]->Misc.VirtualSize), my_data) + Section_Align(MAX(my_data.my_section[my_data.my_file->NumberOfSections - 1]->SizeOfRawData, my_data.my_section[my_data.my_file->NumberOfSections - 1]->Misc.VirtualSize), my_data);
    113. 	Expand_Data.my_section[my_data.my_file->NumberOfSections - 1]->Misc.VirtualSize = Expand_Data.my_section[my_data.my_file->NumberOfSections - 1]->SizeOfRawData;
    114.  
    115. 	Expand_Data.my_optional->SizeOfImage += Section_Align(MAX(my_data.my_section[0]->SizeOfRawData, my_data.my_section[0]->Misc.VirtualSize), my_data);
    116.  
    117. 	void* Temp_Ptr = (char*)Expand_Data.Stretch_Data+ Expand_Data.my_section[Expand_Data.my_file->NumberOfSections - 1]->VirtualAddress+ Section_Align(MAX(my_data.my_section[Expand_Data.my_file->NumberOfSections - 1]->SizeOfRawData, my_data.my_section[Expand_Data.my_file->NumberOfSections - 1]->Misc.VirtualSize),my_data);
    118. 	int temp_size = Section_Align(MAX(my_data.my_section[0]->SizeOfRawData, my_data.my_section[0]->Misc.VirtualSize), my_data);
    119. 	void* Temp_Ptr2 = (char*)my_data.Stretch_Data + my_data.my_section[0]->VirtualAddress;
    120.  
    121. 	memcpy_s(Temp_Ptr, temp_size, Temp_Ptr2, temp_size);
    122.  
    123.  
    124. 	Shrink_PE(Expand_Data);
    125.  
    126. 	FILE* my_file;
    127. 	if (fopen_s(&my_file, filename, "wb") != 0)
    128. 	{
    129. 		cout << "打开文件失败！" << endl;
    130. 		
    131. 	}
    132. 	else
    133. 	{
    134. 		Size = _msize(Expand_Data.Shrink_Data);
    135. 		fwrite(Expand_Data.Shrink_Data, 1, Size, my_file);
    136. 		cout << "写入成功！" << endl;
    137. 	}
    138.  
    139. }
    140.  
    141.  
    142. int PE::Section_Align(int temp, Data& my_data)
    143. {
    144. 	return (temp / my_data.my_optional->SectionAlignment)* my_data.my_optional->SectionAlignment + my_data.my_optional->SectionAlignment;
    145. }
    146.  
    147. int PE::File_Align(int temp, Data& my_data)
    148. {
    149. 	return temp / my_data.my_optional->FileAlignment + my_data.my_optional->FileAlignment;
    150. }
    151.  
    152. void PE::New_Section(char* filename, Data& my_data)
    153. {
    154. 	unsigned int Size; //Size是新文件的大小，是原来的文件大小加上.VirtualSize和SizeOfRawData较大的那个
    155. 	Size = my_data.my_optional->SizeOfHeaders;
    156. 	for (int i = 0;i < my_data.my_file->NumberOfSections; i++)
    157. 	{
    158. 		Size += my_data.my_section[i]->SizeOfRawData;
    159. 	}
    160. 	Size+= my_data.my_section[0]->SizeOfRawData;//这是最终新的文件的大小
    161.  
    162. 	Data New_Data;
    163. 	New_Data.Before_Stretch_Data = (void*)malloc(Size*1);
    164. 	memset(New_Data.Before_Stretch_Data, 0, Size);
    165. 	memcpy_s(New_Data.Before_Stretch_Data, Size, my_data.Before_Stretch_Data, Size - my_data.my_section[0]->SizeOfRawData);//将原来的文件复制过来
    166.  
    167. 	Analyze_PE(New_Data);//让New_Data的dos,file,optional,section有数据
    168. 	
    169. 	//复制新的节表
    170. 	void* Temp_ptr1 = (char*)my_data.Before_Stretch_Data + 0x98 + my_data.my_file->SizeOfOptionalHeader;
    171. 	void* Temp_ptr2 = (char*)New_Data.Before_Stretch_Data + 0x98 + my_data.my_file->SizeOfOptionalHeader + my_data.my_file->NumberOfSections * 0x28;
    172. 	memcpy_s(Temp_ptr2, 0x28, Temp_ptr1, 0x28);
    173. 	//复制新的节
    174. 	Temp_ptr1 = (char*)my_data.Before_Stretch_Data + my_data.my_optional->SizeOfHeaders;//指向.text段
    175. 	Temp_ptr2 = (char*)New_Data.Before_Stretch_Data + Size - my_data.my_section[0]->SizeOfRawData;
    176.  
    177. 	memcpy_s(Temp_ptr2, my_data.my_section[0]->SizeOfRawData, Temp_ptr1, my_data.my_section[0]->SizeOfRawData);//复制完.text段作为新增节
    178.  
    179. 	//接下来要改Header的各项数据
    180. 	New_Data.my_file->NumberOfSections++;
    181. 	New_Data.my_optional->SizeOfImage += my_data.my_section[0]->SizeOfRawData;
    182.  
    183. 	Analyze_PE(New_Data);
    184. 	New_Data.my_section[New_Data.my_file->NumberOfSections - 1]->PointerToRawData = New_Data.my_section[New_Data.my_file->NumberOfSections - 2]->PointerToRawData + New_Data.my_section[New_Data.my_file->NumberOfSections - 2]->SizeOfRawData;
    185. 	int size;
    186. 	if (New_Data.my_section[New_Data.my_file->NumberOfSections - 2]->Misc.VirtualSize >= New_Data.my_section[New_Data.my_file->NumberOfSections - 2]->SizeOfRawData)
    187. 	{
    188. 		size = New_Data.my_section[New_Data.my_file->NumberOfSections - 2]->Misc.VirtualSize;
    189. 	}
    190. 	else
    191. 	{
    192. 		size = New_Data.my_section[New_Data.my_file->NumberOfSections - 2]->SizeOfRawData;
    193. 	}
    194. 	size = size / my_data.my_optional->SectionAlignment + my_data.my_optional->SectionAlignment;
    195. 	New_Data.my_section[New_Data.my_file->NumberOfSections - 1]->VirtualAddress = New_Data.my_section[New_Data.my_file->NumberOfSections - 2]->VirtualAddress+size;
    196.  
    197. 	FILE* my_file;
    198. 	if (fopen_s(&my_file, filename, "wb") == 0)
    199. 	{
    200. 		fwrite(New_Data.Before_Stretch_Data, 1, Size, my_file);
    201. 		cout << "写入成功！" << endl;
    202. 		return;
    203. 	}
    204. 	else
    205. 	{
    206. 		cout << "打开文件失败" << endl;
    207. 		return;
    208. 	}
    209. }
    210.  
    211.  
    212. void PE::Readfile(char* filename,Data& my_data)
    213. {
    214. 	unsigned int size;
    215. 	FILE* datafile;
    216. 	void* data;
    217. 	//打开文件
    218. 	if (fopen_s(&datafile, filename, "rb") != 0)
    219. 	{
    220. 		cout << "打开文件失败" << endl;
    221. 		return;
    222. 	}
    223.  
    224.  
    225. 	else
    226. 	{
    227. 		//获取文件的大小
    228. 		cout << "打开文件成功！" << endl;
    229. 		fseek(datafile, 0, SEEK_END);
    230. 		size = ftell(datafile);
    231. 		fseek(datafile, 0, SEEK_SET);
    232. 		if (size == -1L)
    233. 		{
    234. 			cout << "文件大小判断失败！" << endl;
    235. 			return;
    236. 		}
    237.  
    238. 		//申请内存空间把文件内容保存下来
    239. 		my_data.Before_Stretch_Data = (void*)malloc(size * sizeof(char));
    240.  
    241. 		if (fread_s(my_data.Before_Stretch_Data, size, sizeof(char), size, datafile) == 0)
    242. 		{
    243. 			cout << "写入数据失败！" << endl;
    244. 			return;
    245. 		}
    246. 		cout << "写入数据成功，成功获取Data!" << endl;
    247. 		return ;
    248. 	}
    249.  
    250. }
    251.  
    252. //分析PE结构
    253. void PE::Analyze_PE(Data& my_data)
    254. {
    255. 	if (my_data.Before_Stretch_Data != nullptr)
    256. 	{
    257. 		DWORD* Temp_ptr = (DWORD*)my_data.Before_Stretch_Data;
    258. 		my_data.my_dos = (PIMAGE_DOS_HEADER)Temp_ptr;
    259.  
    260. 		Temp_ptr = (DWORD*)((char*)my_data.Before_Stretch_Data + my_data.my_dos->e_lfanew);
    261. 		Temp_ptr++;
    262. 		my_data.my_file = (PIMAGE_FILE_HEADER)Temp_ptr;
    263.  
    264. 		Temp_ptr = (DWORD*)((char*)Temp_ptr + 0x14);
    265. 		my_data.my_optional = (PIMAGE_OPTIONAL_HEADER)Temp_ptr;
    266.  
    267. 		Temp_ptr = (DWORD*)((char*)my_data.my_optional + my_data.my_file->SizeOfOptionalHeader);
    268. 		my_data.my_section = (PIMAGE_SECTION_HEADER*)malloc(sizeof(IMAGE_SECTION_HEADER) * my_data.my_file->NumberOfSections);
    269. 		for (int i = 0; i < my_data.my_file->NumberOfSections; i++)
    270. 		{
    271. 			my_data.my_section[i] = (PIMAGE_SECTION_HEADER)Temp_ptr;
    272. 			Temp_ptr = (DWORD*)((char*)Temp_ptr + 0x28);
    273. 		}
    274. 		return;
    275. 	}
    276. 	else if(my_data.Stretch_Data!=nullptr)
    277. 	{
    278. 		DWORD* Temp_ptr = (DWORD*)my_data.Stretch_Data;
    279. 		my_data.my_dos = (PIMAGE_DOS_HEADER)Temp_ptr;
    280.  
    281. 		Temp_ptr = (DWORD*)((char*)my_data.Stretch_Data + my_data.my_dos->e_lfanew);
    282. 		Temp_ptr++;
    283. 		my_data.my_file = (PIMAGE_FILE_HEADER)Temp_ptr;
    284.  
    285. 		Temp_ptr = (DWORD*)((char*)Temp_ptr + 0x14);
    286. 		my_data.my_optional = (PIMAGE_OPTIONAL_HEADER)Temp_ptr;
    287.  
    288. 		Temp_ptr = (DWORD*)((char*)my_data.my_optional + my_data.my_file->SizeOfOptionalHeader);
    289. 		my_data.my_section = (PIMAGE_SECTION_HEADER*)malloc(sizeof(IMAGE_SECTION_HEADER) * my_data.my_file->NumberOfSections);
    290. 		for (int i = 0; i < my_data.my_file->NumberOfSections; i++)
    291. 		{
    292. 			my_data.my_section[i] = (PIMAGE_SECTION_HEADER)Temp_ptr;
    293. 			Temp_ptr = (DWORD*)((char*)Temp_ptr + 0x28);
    294. 		}
    295. 		return;
    296. 	}
    297. 	else if (my_data.Shrink_Data != nullptr)
    298. 	{
    299. 		DWORD* Temp_ptr = (DWORD*)my_data.Shrink_Data;
    300. 		my_data.my_dos = (PIMAGE_DOS_HEADER)Temp_ptr;
    301.  
    302. 		Temp_ptr = (DWORD*)((char*)my_data.Shrink_Data + my_data.my_dos->e_lfanew);
    303. 		Temp_ptr++;
    304. 		my_data.my_file = (PIMAGE_FILE_HEADER)Temp_ptr;
    305.  
    306. 		Temp_ptr = (DWORD*)((char*)Temp_ptr + 0x14);
    307. 		my_data.my_optional = (PIMAGE_OPTIONAL_HEADER)Temp_ptr;
    308.  
    309. 		Temp_ptr = (DWORD*)((char*)my_data.my_optional + my_data.my_file->SizeOfOptionalHeader);
    310. 		my_data.my_section = (PIMAGE_SECTION_HEADER*)malloc(sizeof(IMAGE_SECTION_HEADER) * my_data.my_file->NumberOfSections);
    311. 		for (int i = 0; i < my_data.my_file->NumberOfSections; i++)
    312. 		{
    313. 			my_data.my_section[i] = (PIMAGE_SECTION_HEADER)Temp_ptr;
    314. 			Temp_ptr = (DWORD*)((char*)Temp_ptr + 0x28);
    315. 		}
    316. 		return;
    317. 	}
    318.  
    319. 	cout << "分析pe结构失败!" << endl;
    320. 	cout << "失败原因,Data类里三个状态的指针皆为空指针!" << endl;
    321. }
    322.  
    323. //拉伸PE结构   注意看PIMAGE_XXX_HEADER的定义，它们本就是指向结构体的指针
    324. void PE::Stretch_PE(Data& my_data)
    325. {
    326. 	unsigned Memory_Size = 0;
    327. 	Memory_Size = my_data.my_optional->SizeOfImage;
    328. 	my_data.Stretch_Data = (void*)malloc(sizeof(char) * Memory_Size);
    329. 	memset(my_data.Stretch_Data, 0, Memory_Size);
    330. 	void* temp_before_stretch_data_ptr = my_data.Before_Stretch_Data;
    331. 	int size_of_dos = 0x40;
    332. 	int size_of_junk = 0x40;
    333. 	int size_of_file = 0x18;
    334. 	unsigned Size_Of_Optional = my_data.my_file->SizeOfOptionalHeader;
    335. 	unsigned Size_Of_Section = 0x28;
    336. 	unsigned Size_Of_Header = size_of_dos + size_of_file + size_of_junk + Size_Of_Optional + Size_Of_Section * my_data.my_file->NumberOfSections;//还未对齐
    337. 	memcpy_s(my_data.Stretch_Data, Memory_Size, my_data.Before_Stretch_Data, Size_Of_Header);
    338. 	void* temp_stretch_data = my_data.Stretch_Data;
    339. 	//现在计算head头对齐后的大小
    340. 	int Size = Size_Of_Header % my_data.my_optional->SectionAlignment;
    341. 	Size_Of_Header = my_data.my_optional->SectionAlignment * Size;
    342.  
    343.  
    344. 	for (int i = 0; i < my_data.my_file->NumberOfSections; i++)
    345. 	{
    346. 		temp_stretch_data = (void*)((char*)my_data.Stretch_Data + my_data.my_section[i]->VirtualAddress);
    347. 		temp_before_stretch_data_ptr = (void*)((char*)my_data.Before_Stretch_Data + my_data.my_section[i]->PointerToRawData);
    348. 		memcpy_s(temp_stretch_data, my_data.my_section[i]->SizeOfRawData, temp_before_stretch_data_ptr, my_data.my_section[i]->SizeOfRawData);
    349. 	}
    350. 	cout << "拉伸成功" << endl;
    351. }
    352.  
    353.  
    354.  
    355. void PE::Shrink_PE(Data& my_data)
    356. {
    357. 	unsigned int Size = 0;
    358. 	Size = my_data.my_section[my_data.my_file->NumberOfSections - 1]->PointerToRawData + my_data.my_section[my_data.my_file->NumberOfSections - 1]->SizeOfRawData;
    359. 	my_data.Shrink_Data = (void*)malloc(Size);
    360.  
    361. 	//从Stretch_Data缩小
    362.  
    363. 	//复制Heads
    364. 	memcpy_s(my_data.Shrink_Data, my_data.my_optional->SizeOfHeaders, my_data.Stretch_Data, my_data.my_optional->SizeOfHeaders);
    365.  
    366. 	//复制节
    367. 	void* temp_shrink_data_ptr = my_data.Shrink_Data;
    368. 	void* temp_stretch_data_ptr = my_data.Stretch_Data;
    369. 	for (int i = 0; i < my_data.my_file->NumberOfSections; i++)
    370. 	{
    371. 		temp_shrink_data_ptr = (void*)((char*)my_data.Shrink_Data + my_data.my_section[i]->PointerToRawData);
    372. 		temp_stretch_data_ptr = (void*)((char*)my_data.Stretch_Data + my_data.my_section[i]->VirtualAddress);
    373. 		memcpy_s(temp_shrink_data_ptr, my_data.my_section[i]->SizeOfRawData, temp_stretch_data_ptr, my_data.my_section[i]->SizeOfRawData);
    374. 	}
    375. 	cout << "缩小成功" << endl;
    376. 	return;
    377.  
    378. }
    379.  
    380.  
    381. int main()
    382. {
    383. 	char filename[100]= "ceshi.exe";
    384. 	PE my_pe;
    385. 	Data my_data;
    386. 	my_pe.Readfile(filename,my_data);
    387. 	my_pe.Analyze_PE(my_data);   //char*& Data, PIMAGE_DOS_HEADER& dos, PIMAGE_FILE_HEADER& file, PIMAGE_OPTIONAL_HEADER32& optional, PIMAGE_SECTION_HEADER*& section
    388. 	my_pe.Stretch_PE(my_data);
    389. 	my_pe.Shrink_PE(my_data);
    390.  
    391. 	/*char filename2[100] = "666.exe";
    392. 	my_pe.New_Section(filename2, my_data);*/
    393.  
    394. 	char filename3[100] = "555.exe";
    395. 	my_pe.Expand_Section(my_data,filename3);
    396. 	return 0;
    397. 	
    398. }

    至于刚刚提到的问题，我查看汇编代码发现了些许端倪
     

    1. 004C2E4B C7 45 FC FF FF FF FF mov         dword ptr [ebp-4],0FFFFFFFFh  
    2. 004C2E52 8D 4D B8             lea         ecx,[Expand_Data]  
    3. 004C2E55 E8 08 E4 FF FF       call        Data::~Data (04C1262h)  
    4. 004C2E5A 52                   push        edx  
    5. 004C2E5B 8B CD                mov         ecx,ebp  
    6. 004C2E5D 50                   push        eax  
    7. 004C2E5E 8D 15 98 2E 4C 00    lea         edx,ds:[4C2E98h]  
    8. 004C2E64 E8 03 E4 FF FF       call        @_RTC_CheckStackVars@8 (04C126Ch)  
    9. 004C2E69 58                   pop         eax  
    10. 004C2E6A 5A                   pop         edx  
    11. 004C2E6B 8B 4D F4             mov         ecx,dword ptr [ebp-0Ch]  
    12. 004C2E6E 64 89 0D 00 00 00 00 mov         dword ptr fs:[0],ecx  
    13. 004C2E75 59                   pop         ecx  
    14. 004C2E76 5F                   pop         edi  
    15. 004C2E77 5E                   pop         esi  
    16. 004C2E78 5B                   pop         ebx  
    17. 004C2E79 8B 4D F0             mov         ecx,dword ptr [ebp-10h]  
    18. 004C2E7C 33 CD                xor         ecx,ebp  
    19. 004C2E7E E8 21 E3 FF FF       call        @__security_check_cookie@4 (04C11A4h)  
    20. 004C2E83 81 C4 3C 01 00 00    add         esp,13Ch  
    21. 004C2E89 3B EC                cmp         ebp,esp  
    22. 004C2E8B E8 4F E4 FF FF       call        __RTC_CheckEsp (04C12DFh)  
    23. 004C2E90 8B E5                mov         esp,ebp  
    24. 004C2E92 5D                   pop         ebp  
    25. 004C2E93 C2 08 00             ret         8

    这是我传值引用的结果，可以看到只调用了Expand_Data这个类的析构函数，符合常理，但是一旦我将void PE:: Expand_Section(Data& my_data,char* filename)改为void PE:: Expand_Section(Data my_data,char* filename) 我们再反汇编，此时就有问题了！

    1. 00AB2E0A C6 45 FC 00          mov         byte ptr [ebp-4],0  
    2. 00AB2E0E 8D 4D B8             lea         ecx,[Expand_Data]  
    3. 00AB2E11 E8 4C E4 FF FF       call        Data::~Data (0AB1262h)  
    4. 00AB2E16 C7 45 FC FF FF FF FF mov         dword ptr [ebp-4],0FFFFFFFFh  
    5. 00AB2E1D 8D 4D 08             lea         ecx,[my_data]  
    6. 00AB2E20 E8 3D E4 FF FF       call        Data::~Data (0AB1262h)  
    7. 00AB2E25 52                   push        edx  
    8. 00AB2E26 8B CD                mov         ecx,ebp  
    9. 00AB2E28 50                   push        eax  
    10. 00AB2E29 8D 15 64 2E AB 00    lea         edx,ds:[0AB2E64h]  
    11. 00AB2E2F E8 38 E4 FF FF       call        @_RTC_CheckStackVars@8 (0AB126Ch)  
    12. 00AB2E34 58                   pop         eax  
    13. 00AB2E35 5A                   pop         edx  
    14. 00AB2E36 8B 4D F4             mov         ecx,dword ptr [ebp-0Ch]  
    15. 00AB2E39 64 89 0D 00 00 00 00 mov         dword ptr fs:[0],ecx  
    16. 00AB2E40 59                   pop         ecx  
    17. 00AB2E41 5F                   pop         edi  
    18. 00AB2E42 5E                   pop         esi  
    19. 00AB2E43 5B                   pop         ebx  
    20. 00AB2E44 8B 4D F0             mov         ecx,dword ptr [ebp-10h]  
    21. 00AB2E47 33 CD                xor         ecx,ebp  
    22. 00AB2E49 E8 56 E3 FF FF       call        @__security_check_cookie@4 (0AB11A4h)  
    23. 00AB2E4E 81 C4 3C 01 00 00    add         esp,13Ch  
    24. 00AB2E54 3B EC                cmp         ebp,esp  
    25. 00AB2E56 E8 84 E4 FF FF       call        __RTC_CheckEsp (0AB12DFh)  
    26. 00AB2E5B 8B E5                mov         esp,ebp  
    27. 00AB2E5D 5D                   pop         ebp  
    28. 00AB2E5E C2 20 00             ret         20h

    可以看到他居然调用了my_data的析构！这也是导致程序崩溃的原因，因为在main函数中，函数结束后，也会调用my_data的析构，等于调用了析构函数两次！

    具体原因查了下资料对象作为参数按值传递为什么会调用析构函数？为什么实参中的内容会被修改？_c++ 类作为参数传递 在函数中被修改-CSDN博客

    引用大佬的文章

    对象作为参数按值传递为什么会调用析构函数？为什么实参中的内容会被修改？

    因为对象按值传递时，编译器自动生成的复制构造函数进行了指针的简单拷贝，像指针直接赋值 str=s 一样，而没有拷贝指针指向的内容，这样当你将对象传递给函数时确实会有一个拷贝，但是这个拷贝会有一个指针的拷贝，所以两个对象中的 str 指向的内存一样，在退出函数时，析构销毁了函数中对象中的指针，但不幸的是这样实参对象 str 指向的内容也被销毁。

    哎，c++没学好是这样的，但也算收获蛮多 

     

  • 相关阅读:
    Java版本+企业电子招投标系统源代码+支持二开+招投标系统+中小型企业采购供应商招投标平台
    智能AI系统源码ChatGPT系统源码+详细搭建部署教程+AI绘画系统+已支持OpenAI GPT全模型+国内AI全模型
    PostgreSQL数据库体系结构
    阿里巴巴中国站按关键字搜索工厂数据 API 返回值说明
    Android开发-Mac Android开发环境搭建(Android Studio Mac环境详细安装教程，适合新手）...
    行政人事的日常丨每个人心里都有一团火
    【初阶与进阶C++详解】第十一篇：stack和queue
    【宝塔安装教程】2分钟装好面板，一键管理服务器
    使用CSS变量实现主题定制真的很简单
    LabView中顺序结构的使用
  • 原文地址：https://blog.csdn.net/fzucaicai/article/details/133499655