[pwnable.xyz] fishing - thread

🧡 fishing 설명

pwnable.xyz 문제 중에 재미있게 푼 문제가 있어서 소개해보려고 한다. binary를 봐보도록 하자.

undefined8 main(void)

{
  undefined4 uVar1;
  
  setup();
  banner();
  do {
    show_menu();
    uVar1 = read_int();
    switch(uVar1) {
    default:
      err("Invalid choice");
      break;
    case 1:
      add_group_member();
      break;
    case 2:
      modify_group_member();
      break;
    case 3:
      write_in_book();
      break;
    case 4:
      go_fishing();
      break;
    case 5:
      stop_fishing();
      break;
    case 6:
      puts("Bye. I\'m keeping the deposit");
      return 0;
    }
  } while( true );
}

main 함수는 이렇게 생겼다.

void add_group_member(void)

{
  undefined4 uVar1;
  void **ppvVar2;
  void *pvVar3;
  
  if (group_size < 6) {
    ppvVar2 = (void **)malloc(0x20);
    pvVar3 = malloc(0x18);
    *ppvVar2 = pvVar3;
    __printf_chk(1,"Name: ");
    read_string(*ppvVar2,0x18);
    pvVar3 = malloc(0x18);
    ppvVar2[1] = pvVar3;
    __printf_chk(1,"Job: ");
    read_string(ppvVar2[1],0x18);
    __printf_chk(1,"Age: ");
    uVar1 = read_int();
    *(undefined4 *)(ppvVar2 + 2) = uVar1;
    *(void ***)(group + (long)group_size * 8) = ppvVar2;
    group_size = group_size + 1;
    return;
  }
  puts("You would sink the boat with that many people");
  return;

group member을 생성하는 함수다. heap 구조는 대충 이렇게 생겼다.

void modify_group_member(void)

{
  undefined8 *puVar1;
  uint uVar2;
  undefined4 uVar3;
  
  puts("Which person do you need to change?");
  uVar2 = read_int();
  if (5 < uVar2) {
    puts("A group member can only be 0-5");
    return;
  }
  puVar1 = *(undefined8 **)(group + (long)(int)uVar2 * 8);
  if (puVar1 != (undefined8 *)0x0) {
    __printf_chk(1,"Name: ");
    read_string(*puVar1,0x18);
    __printf_chk(1,"Job: ");
    read_string(puVar1[1],0x18);
    __printf_chk(1,"Age: ");
    uVar3 = read_int();
    *(undefined4 *)(puVar1 + 2) = uVar3;
    return;
  }
  puts("That person doesn\'t exist");
  return;
}

단순히 group member의 정보를 수정하는 함수다.

void write_in_book(void)

{
  void *pvVar1;
  
  puts("What do you want to say?");
  pvVar1 = malloc(0x20);
  read_string(pvVar1,0x20);
  return;
}

아무런 조건 없이 0x20 size를 가진 heap을 생성할 수 있다.

void go_fishing(void)

{
  long in_FS_OFFSET;
  pthread_t pStack24;
  long local_10;
  
  local_10 = *(long *)(in_FS_OFFSET + 0x28);
  if (fishing == 0) {
    if (group_size < 2) {
      puts("You need 2 or more people to fish");
    }
    else {
      fishing = 1;
      pthread_create(&pStack24,(pthread_attr_t *)0x0,gone_fishing,(void *)0x0);
      puts("You\'re group has now left to catch some fish");
    }
  }
  else {
    puts("You\'re group is already fishing, wait until they come back");
  }
  if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
    return;
  }
                    /* WARNING: Subroutine does not return */
  __stack_chk_fail();
}

 이 부분이 재미있는데, 일단 낚시를 가려면 group size가 2 이상이어야 한다. 그리고, gone_fishing 함수를 실행하는데 이 부분에서 스레드를 생성한다. 

void remove_person(int param_1)

{
  void **__ptr;
  
  __ptr = *(void ***)(group + (long)param_1 * 8);
  if (__ptr != (void **)0x0) {
    free(*__ptr);
    free(__ptr[1]);
    free(__ptr);
    return;
  }
  return;
}

undefined8 gone_fishing(void)

{
  int iVar1;
  
  iVar1 = pthread_mutex_lock((pthread_mutex_t *)mutex);
  if (iVar1 != 0) {
    err("Fatal locking");
  }
  iVar1 = group_size + -1;
  puts("\n!!!!ALERT!!!");
  __printf_chk(1,"%s has fallen over board\n",**(undefined8 **)(group + (long)iVar1 * 8));
  puts("We are trying to save them");
  remove_person(iVar1);
  iVar1 = pthread_cond_wait((pthread_cond_t *)cond,(pthread_mutex_t *)mutex);
  if (iVar1 != 0) {
    err("Fatal");
  }
  puts("\nOk we are coming back. Btw they died...");
  group_size = group_size + -1;
  fishing = 0;
  iVar1 = pthread_mutex_unlock((pthread_mutex_t *)mutex);
  if (iVar1 != 0) {
    err("Fatal unlocking");
  }
  return 0;
}

 이 함수는 이렇게 생겼다. 일단 함수를 실행하면 mutex를 이용해 스레드에 락을 건다. 그리고 아주 불쌍하게도 마지막 그룹에 있는 사람은 갑판 밑으로 떨어지게 된다 ㅠㅠ.. 떨어진 그룹을 인자로 갖고 remove_person을 실행하는데 이 함수에서 문제가 발생한다. 

 heap을 할당하는 순서는 name -> job 순서인데, 해당 함수에서는 반대로 free 한다. 또한 전역변수에 있는 data와 heap에 있는 data를 지우지 않기 때문에 UAF가 발생한다.

 그리고 cond signal이 올 때까지 스레드를 대기 상태로 전환한다.

void stop_fishing(void)

{
  int iVar1;
  
  if (fishing == 0) {
    puts("You\'re group is not fishing");
    return;
  }
  iVar1 = pthread_cond_signal((pthread_cond_t *)cond);
  if (iVar1 == 0) {
    return;
  }
  err("Fatal signaling");
  return;
}

이 함수를 실행하면 cond signal을 발생시킨다.

 

🧡 Attack Vector

위에서 말했다 싶이 UAF를 이용해서 heap을 조작하면 된다. 적당히 만져주고 heap_base, pie_base를 leak한 다음에 GOT overwrite로 win 함수를 실행해주면 끝난다.