Báo-cáo-CSATTT-Lớp-D14ATTT-01-Nhóm-03

HỌC VIỆN CƠNG NGHỆ BƯU CHÍNH VIỄN THƠNG


BÁO CÁO TIỂU ḶN
CƠ SỞ AN TOÀN THƠNG TIN
Đề tài: Tìm hiểu về tấn công gây tràn bộ đệm buffer overflow

Giảng viên: Hoàng Xuân Dậu
Nhóm Bài Tập Lớn: 03
Danh sách thành viên:
Lê Thị Đính B14DCAT046
Đinh Duy Đơng B14DCAT217
Đào Mạnh Đức B14DCAT043
Lê Hoàng Đức B14DCAT218

1


Mục Lục
I. TỔNG QUAN VỀ LỖI TRÀN BỘ ĐỆM BUFFER OVERFLOW.........................2
1. Khái niệm..................................................................................................................2
2. Lỗi Buffer Overflow và nguyên nhân gây lỡi............................................................3
3. Stack Overflow.............................................................................................................4
3.1 Định nghĩa:..............................................................................................................4
3.2 Mục đích chính của Stack buffer overflow:.............................................................5
4. HEAP OVERFLOW:....................................................................................................8
4.1 Định nghĩa:..............................................................................................................8
4.2 OVERWRINGTING POINTERS (viết lại con trỏ):.................................................9
4.3 Khai thác thư viện malloc():..................................................................................10
4.4 Mục đích của việc làm hỏng cấu trúc DLMALLOC:.............................................11
II.

CÁCH PHÁT HIỆN BUFFER OVERFLOW.....................................................12

III. CÁCH PHỊNG TRÁNH BUFFER OVERFLOW.............................................13
1. Lựa chọn ngơn ngữ lập trình:.....................................................................................14
2 Sử dụng thư viện an tồn:............................................................................................14
3 Chống tràn bộ đệm trên Stack:....................................................................................15
4. Bảo vệ không gian thực thi:........................................................................................15
5. Ngẫu nhiên hóa sơ đồ khơng gian địa chỉ:.................................................................15
6. Kiểm tra sâu đối với gói tin........................................................................................15
IV.

DEMO.....................................................................................................................16

V. KẾT LUẬN................................................................................................................16
VI. TÀI LIỆU THAM KHẢO.....................................................................................17

2


I.

TỔNG QUAN VỀ LỖI TRÀN BỘ ĐỆM BUFFER OVERFLOW

1. Khái niệm
Lỗi tràn bộ đệm là một điều kiện bất thường khi một tiến trình lưu dữ liệu vượt ra
ngoài biên của bộ nhớ đệm có chiều dài cố định. Kết quả là dữ liệu có thể đè lên các bộ
nhớ liền kề. Dữ liệu bi ghi đè có thề bao gồm các bộ nhớ đệm khác, các biến và dữ liệu
điều khiển luồng chảy của chương trình (program flow control).
Các lỡi tràn bộ đệm có thề làm cho tiến trình bị đổ vỡ hoặc cho ra kết quả sai. Các

lỗi này có thể được kích hoạt bởi các dữ liệu vào được thiết kế đặc biệt để thưc thi các
đoạn mả phá hoại hoặc để làm cho chương trình hoạt động không như mong đợi. Bằng
cách đó các lỗi tràn bộ đệm gây ra nhiều lổ hổng bảo mật đối với phần mềm và tạo cơ sở
cho nhiều thủ thuật khai thác.
Chương trình khi nạp trong bộ nhớ:
Khi những tiến trình được nạp đến bộ nhớ, chúng chia thành 6 phân đoạn như sau:

Hình 1.1: Các phân đoạn chương trình thực thi
- text: phân đoạn này tương ứng là phần của file thực thi nhị phân. Nó chứa các chỉ thị
lệnh (mã máy) để thực hiện các tác vụ của chương trình. Phân đoạn này được đánh
dấu là chỉ đọc và sẽ gây ra lỗi nếu như ghi trên phân đoạn này. Kích thước là cố
định tại lúc thực thi khi tiến trình lần đầu tiên được nạp.
- data: là phân đoạn được sử dụng để lưu trữ các biến toàn cục và có khởi tạo giá trị
ban đầu như là: int a=0; kích thước này cũng cố định tại lúc thực thi chương trình.
- bss (Below stack section) là được sử dụng để lưu trữ các biến toàn cục nhưng không
có khởi tạo giá trị ban đâu như là: int a. Kích thước của phân đoạn này cũng cố
định lúc thực thi chương trình.
3


- Heap: Phân đoạn này được sử dụng để cấp phát các biến động và phát triển từ vùng
địa chỉ thấp đến vùng địa chỉ cao trong bộ nhớ. Trong ngơn ngữ C thì việc cấp phát
và giải phóng được thực hiện qua hai hàm malloc() và free().
Ví dụ: int i = malloc(sizeof (int));
- Stack: phân đoạn stack có tác dụng giữ những lời gọi hàm trong thủ tục đệ quy và
phát triển theo địa chỉ vùng nhớ cao đến địa chỉ vùng nhớ thấp trên hầu hết các hệ
thống.
- Phân đoạn biến môi trường và đối số: phân đoạn này lưu trữ một bản sao chép các
biến cấp độ hệ thống mà có thể được yêu cầu bởi tiến trình trung quá trình thực thi.
Phân đoạn này có khả năng ghi được.

Trong các ngơn ngữ lập trình thì ngơn ngữ C dễ sinh ra các lỗi tràn nhớ mà attacker
có thể khai thác. Trong ngôn ngữ C, các chuỗi (string) hay các buffer được thể hiện như
sau: Con trỏ (pointer) sẽ chỉ trỏ vào byte đầu tiên của chuỗi hay buffer đó,và chúng ta xác
định được kết điểm kết thúc khi con trỏ trỏ đến 1 byte null → không xác định độ dài của
đối tượng nhập vào → có thể copy 1 buffer có độ dài lớn vào 1 buffer có độ dài nhỏ hơn
→ gây tràn bộ nhớ đệm (buffer overflow).
Ví dụ một lỡi đơn giản:
#include<stdio.h>
Int main (int argc, char **argv)
{
char target [5] = “TTTT”;
char attacker [11] = “AAAAAAAA”;
strcpy(attacker, “DDDDDDDDDDDDD”);
printf(“% \n”,target);
return 0;
}
2. Lỗi Buffer Overflow và nguyên nhân gây lỗi
4


Thông thường có 2 cách khai thác lỗi buffer overflow mà attacker có thể sử dụng:
- Khai thác dựa vào các lỗ hỏng phần mền thông qua ngôn ngữ lập trình (phần mềm
viết bằng ngơn ngữ C).
- Khai thác các trang web có tương tác người dùng nhưng không ràng buộc dữ liệu
nhập vào như các trường username, password ...
Nguyên nhân gây ra các lỗi buffer overflow của các chương trình và ứng dụng:
- Phương thức kiểm tra biên (boundary) không được thực hiện đầy đủ, hoặc là được
bỏ qua.
- Các ngơn ngữ lập trình, như là ngơn ngữ C, bản thân nó đã tiềm ẩn các lỗi mà
hacker có thể khai thác. Các phương thức strcat(), strcpy(), sprintf(), bcopy(),

gets(), và canf() trong ngôn ngữ C có thể được khai thác vì các hàm này khơng
kiểm tra xem những buffer được cấp phát trên stack có kích thước lớn hơn dữ liệu
được copy vào buffer hay khơng.
- Những chương trình hoặc ứng dụng được lập trình khơng tốt khi tạo ra nó (khả năng
lập trình kém).
Một lỡi buffer overflow xuất hiện khi buffer cố gắng cấp phát 1 không gian lưu trữ
có dữ liệu lớn hơn khả năng lưu trữ của nó.
Có 2 kiểu Buffer Overflow chính:
- Stack overflow
- Heap overflow
Stack (nơi lưu trữ tĩnh của không gian bộ nhớ)
Heap (nơi lưu trữ động của không gian bộ nhớ, được sinh ra khi chạy một chương
trình) là địa điểm lưu trữ cung cấp cho các biến khi chạy một chương trình. Biến được
lưu trữ trong stack hoặc heap cho đến khi chương trình có nhu cầu sử dụng.
3. Stack Overflow
3.0 Định nghĩa:
5


Stack là một kiểu cấu trúc dữ liệu hoạt động theo cơ chế LIFO (last in first out) được
máy tính sử dụng để truyền các đối số vào các hàm để tham chiếu đến các biến cục bộ.
Stack sẽ lưu giữ tất cả các thông tin mà hàm cần Stack được khởi tạo khi bắt đầu của
một hàm và được “phóng thích” khi hàm kết thúc.
Stack overflow xuất hiện khi buffer tràn trong stack space. Đoạn code độc hại sẽ được
push vào stack.
Lỗi tràn nhớ có thể viết lại giá trị của return pointer, vì thế hacker có thể điều khiển
con trỏ tới các đoạn code độc hại mà họ muốn thực thi.

Hình 2.1: Stack
mỢT

3.0 Mục đích chính của Stack buffer overflow:
Ghi đè một biến địa phương nằm gần bộ nhớ đệm trong stack đê thay đổi hành vi
của chương trình nhằm phục vụ cho ý đồ của hacker
Ghi đè địa chỉ trả về trong khung stack (stack frame). Khi hàm trả về thưc thi sẽ
được tiếp tục tại địa chỉ mà hacker đã chỉ rõ, thường là tại một bộ đệm chứa dữ liệu vào
của người dùng
Ví dụ:
6


void thung(){
char bia[10]; //chai bia chỉ chứa được 10ml
gets(bia); //nhập vào số bia
}
Với chương trình này của chúng ta, nhiệm vụ của chương trình này là yêu cầu người
dùng nhập vào số bia cần bỏ vô chai với chai bia chỉ có 10ml.
Điều gì xảy ra khi người dùng tham lam nhập vào số bia là 20ml?
Nếu người dùng tham lam, lấy 20ml thì chắn chắn nó sẽ bị tràn, gây ra lỗi. Vậy khi chúng
ta gọi hàm thung(), nó sẽ làm một chỗ trống cho biến bia[] trên stack.

Cách sắp xếp dữ liệu của stack.
Nhiệm vụ của chúng ta bây giờ là ghi đè bia[] với mã độc cho đến khi biến bia[] tràn.
Khi bị tràn, chúng ta có thể ghi đè luôn cả địa chỉ trả về bằng địa chỉ của biết bia[]. Thì
khi mà hàm thung() thực thi xong, thay vì nó trở về nơi nó cần thực thi tiếp thì, nó sẽ
quay lại địa chỉ của biến bia[] và thực thi mã độc trong đó.

7


Và đây là stack của chúng ta khi làm điều trên

Hình 2.2: Stack khi bị tấn cơng bởi Atacker

Người dùng thông thạo có ý đồ xấu:
- Khai thác dựa vào các lỗ hổng phần mềm thông qua ngôn ngữ lập trình (phần mềm
thường được viết bằng ngơn ngữ C).
- Ghi đè địa chỉ trả về trong một khung (stack frame). Khi hàm trả về, thực thi sẽ
được tiếp tục tại địa chỉ mà kẻ tấn công đã chỉ rõ, thường là tại một bộ đệm chứa
dữ liệu vào của người dùng.
8


- Khai thác các trang web có tương tác người dùng nhưng không ràng buộc dữ liệu
nhập như các trường hợp username, password,...
3. HEAP OVERFLOW:
4.0 Định nghĩa:
Heap là một khu vực của bộ nhớ được sử dụng bởi một ứng dụng và được cấp phát
động tại thời gian chạy của các hàm, chẳng hạn như malloc().
Heap lưu trữ tất cả các trường hoặc thuộc tính, hàm tạo và phương thức của một lớp
hoặc một đối tượng.
Các biến được cấp phát tự động trong hàm, như malloc() được tạo ra trong heap.

Hình 2.3: Heap
Trong cách tấn cơng heap overflow, attacker làm tràn bộ nhớ sẽ có thể overwrite các
dynamic variables, vì thế có thể dẫn đến các hiệu ứng không mong muốn. Trong hầu hết
các môi trường ứng dụng, việc này có thể giúp attacker có thể điều khiển các thực thi của
chương trình.
Ví dụ:

9

Hình 2.4: Ví dụ Heap Overflow
Heap trước và sau khi bị lỡi Buffer Overflow:

Hình 2.5: Heap Overflow
4.0 OVERWRINGTING POINTERS (viết lại con trỏ):
Kẻ tấn công có thể sử dụng phương pháp này để viết lại filename, password ,uid..
Các dạng tấn công dựa vào heap:

10


Cuộc tấn công kiểu này cần một số điều kiện tiên quyết trong mã nguồn của
vulnerable binary: một định nghĩa buffer và pointer. Khó khăn của phương pháp này là
tìm ra hai điều kiện tiên quyết như trên.Một khó khăn khác là xác định địa chỉ của
vulnerable program. Overwriting function pointers.
Mục đích: attacker muốn ghi đè lên một con trỏ và làm cho nó trỏ đến những gì họ
muốn. Nó có thể trỏ đến 1 chương trình nào đó.

4.0 Khai thác thư viện malloc():
Dlmalloc được gọi là thư viện Doug Lea malloc, và cũng là malloc thư viện được sử
dụng bởi LIBC.

11


 U: Used chunk
 F: Free chunk
 Wilderness: top most free chunk

Định nghĩa cấu trúc của 1 đoạn (trunk) là:
struct malloc_chunk
{
size_t prev_size; // only used when previous chunk is free
size_t size; // size of chunk in bytes + 2 status-bits
struct malloc_chunk *fd; // only used for free chunks: pointer to next chunk
struct malloc_chunk *bk; // only used for free chunks: pointer to previous
chunk
}
;
4.0 Mục đích của việc làm hỏng cấu trúc DLMALLOC:
Attacker làm tràn bộ nhớ,sau đó ghi đè dữ liệu lên các mục tiêu của họ.
Yêu cầu đặc biệt cho một dlmalloc khai thác là có hai khối bộ nhớ thu được bằng
malloc.
Ví dụ: vudu2.c
int main(void)
{
char * buf ;
char * buffer1 = (char *)malloc(666) ;
12


char * buffer2 = (char *)malloc(2);
printf(Enter something: );
gets(buf);
strcpy (buffer1, buf);
free(buffer1);
free(buffer2);
return (1);
}

Sau khi thực thi khai thác lỗi ta có kết quả sau:

II.

CÁCH PHÁT HIỆN BUFFER OVERFLOW

Có 2 cách cơ bản để phát hiện các lỗi buffer overflow mà hacker có thể sử dụng :
- Nhìn vào source code: Hacker tìm kiếm các string là các biến cục bộ trong các hàm
của chương trình, xem xét chúng có được kiểm tra biên (boundary check) chưa.
Kiểm tra tiêu chuẩn của các hàm có liên quan đến phần các chuỗi trong phần input,
output.
13


- Nhập vào các ứng dụng một dữ liệu rất lớn và xem xét ứng dụng có bất cứ biểu
hiện khơng bình thường nào khơng.
Các bước xác định Buffer Overflow:
- Bước 1: chạy máy chủ web trên máy cục bộ
- Bước 2: Phát yêu cầu với mọi thẻ dài thẻ kết thúc với “$$$$$”
- Bước 3: nếu máy chủ web bị treo, tìm kiếm bãi tập kết lõi của “$$$$$” để tìm kiếm
vị trí tràn.
- Bước 4: sử dụng các công cụ tự động như codeBlocker, eEye Retina, …
- Bước 5: Sử dụng bộ phận phân tách và trình gỡ rối
- Bước 6: Sử dụng IDA-Proto để xây dựng lại nơi bị khai thác

Hình 2.6: Các bước xác định Buffer Overflow
III.

CÁCH PHÒNG TRÁNH BUFFER OVERFLOW

Các cách có thể cản trở đối các kĩ thuật khai thác lỗi buffer overflow: xử lý bộ đệm
trước khi đọc hay thực thi có thể làm thất bại các cố gắng khai thác lỗi tràn bộ đệm nhưng
vẫn không ngăn chặn được một cách tuyệt đối
+ Chuyển từ chữ hoa thành chữ thường
14


+ Loại bỏ các kí tự đặc biệt và lọc các xâu khơng chứa kí tự là chữ số hoặc chữ cái.
Tuy nhiên vẫn có các kĩ thuật để tránh việc lọc và xử lý này:
- alphanumeric code :mã gồm toàn chữ và số
- polumorphic code : mã đa hình
- Self-modifying code : mã tự sửa đổi
- Tấn công kiểu return-to-libc
Vì thế để tránh các nguy cơ bị khai thác lỗi buffer overflow chúng ta cần sử dụng
các biện pháp phịng tránh hiệu quả hơn.
0. Lựa chọn ngơn ngữ lập trình:
Ngơn ngữ lập trình có một ảnh hưởng lớn đối với sự xuất hiện lỗi tràn bộ đệm:
- Ngôn ngữ lập trình C và C++ là hai ngơn ngữ lập trình thơng dụng, nhưng hạn chế của
nó là khơng kiểm tra việc truy cập hoặc ghi đè dữ liệu thông qua các con trỏ. Cụ thể nó
không kiểm tra dữ liệu copy vào một mảng có phù hợp kích thước của mảng hay không
- Cyclone, một biến thể của C, giúp ngăn chặn các lỗi tràn bộ đệm bằng việc gắn thơng
tin về kích thước mảng với các mảng.
- Ngơn ngữ lập trình D sử dụng nhiều kĩ thuật đa dạng để tránh gần hết việc sử
dụng con trỏ và kiểm tra biên do người dùng xác định.
- Nhiều ngôn ngữ lập trình khác cung cấp việc kiểm tra tại thời gian chạy. Việc kiểm tra
này cung cấp một ngoại lệ hay 1 cảnh báo khi C hay C++ ghi đè dữ liệu, ví dụ như:
Pythol, Ada, Lisp.
- Ngoài ra các mơi trường của Java hay .NET cũng địi hỏi kiểm tra biên đối với tất cả các
mảng
0 Sử dụng thư viện an toàn:

Sử dụng các thư viện được viết tốt và đã được kiểm thử dành cho các kiểu dữ liệu
trừu tượng mà các thư viện này thực hiện tự động việc quản lý bộ nhớ, trong đó có kiểm
tra biên có thể làm giảm sự xuất hiện và ảnh hưởng của các hiện tượng tràn bộ đệm.
Các thư viện an toàn gồm có: The Better String Library, Arri Buffer API và Vstr.
15


0 Chống tràn bộ đệm trên Stack:
Stack-smashing protection là kỹ thuật dùng để phát hiện các hiện tượng tràn bộ đệm
phổ biến nhất. Kỹ thuật này kiểm tra xem stack đã bị sửa đổi hay chưa khi một hàm trả
về. Nếu stack đã bị sửa đổi, chương trình kết thúc bằng một lỗi segmentation fault.
Chế độ Data Execution Prevention (cấm thưc thi dữ liệu) của Microsoft bảo vệ các
con trỏ và không cho chúng bị ghi đè.
Có thể bảo vệ stack bằng cách phân tán stack thành 2 phần, một phần dành cho dữ
liệu và một phần dành cho các bước trà về của hàm. Sự phân chia này được dùng trong
ngôn ngữ Forth.
0. Bảo vệ không gian thực thi:
Kĩ thuật này ngăn chăn việc thực thi mã tại stack hay heap. Hacker có thể sử dụng
tràn bộ đệm để chèn một đoạn mã tùy ý vào bộ nhớ của chương trình, với việc bảo vệ
khơng gian thực thi mọi cố gắng chạy doặn mã đó sẽ gây ra một ngoại lệ
Một số CPU hỡ trợ một tính năng có tên bit NX (No eXecute) hoặc bit XD (eXecute
Disable). Khi kết hợp với phần mềm các tính năng này có thể được dùng để đánh dấu các
trang dữ liệu (chẳng hạn như các trang chứa stack và heap) là đọc được chứ không thực
thi được.
Các biến thể mới của Microsoft Windows cũng hỗ trợ bảo vệ không gian thực thi
với tên gọi Data Execution Prevention và các phần mềm gắng kèm bao gồm:
SecureStack, OverflowGuard, BufferShield.
0. Ngẫu nhiên hóa sơ đồ không gian địa chỉ:
Ngẫu nhiên hóa sơ đồ không gian địa chỉ (Address space layout randomization
ASLR) là một tín năng an ninh máy tính có liên quan tới việc sắp xếp các vùng dữ liệu

quan trọng (thường bao gồm nơi chúa mã thưc thi và vị trí các thư viện, heap va stack)
một cách ngẫu nhiên trong không gian địa chỉ của một tiến trình.
0. Kiểm tra sâu đối với gói tin

16


Biện pháp kiểm tra sâu đối với gói tin (deep packet inspection-DPI) có thể phát hiện
việc cố gắng khai thác lỗi trán bộ đệm từ xa ngay từ biên giới mạng. Các kĩ thuật này có
khả năng ngăn chặn các gói tin có chứa chữ ký của một vụ tấn công đã biết hoặc chứa các
chuỗi dài các lệnh No-Operation (NOP- lệnh rỡng khơng làm gì).
Việc rà gói tin khơng phải là một phương pháp hiệu quả vì nó chỉ có thể ngăn chặn
các cuộc tấn công đã biết và có nhiều cách để mã hóa một lệnh NOP.
IV.

DEMO

Code chương trình C
#include <stdio.h>
greeting(char *temp1, char *temp2)
{
char name[400];
strcpy(name, temp2);
printf("Xin chao %s %s\n", temp1, name);
}
main(int argc, char *argv[])
{
greeting(argv[1], argv[2]);
printf("Tam biet %s %s\n", argv[1], argv[2]);
}

Nhiệm vụ của chương trình đơn giản là thực hiện nhận hai tham số và chuyển cho
hàm getting(), tại hàm getting() có sử dụng một hàm strcpy có nhiệm vụ copy biến temp2
đến biến name. Tại đây biến name chỉ được cấp phát 400 byte. Do vậy nếu như biến
temp2 khơng lớn hơn 400 thì khơng có việc gì xảy ra, ngược lại nếu như biến temp2 có
giá trị lớn 400, thì nó sẽ lần lượt ghi đè lên địa chỉ EBP và EIP, vì sao nó lại ghi đè lên hai
địa chỉ này thì như đã giới thiệu trong phần cách hoạt động của stack. Từ đây có thể xuất
hiện lỗi.
V.

KẾT LUẬN
17


Thực tế chỉ ra rằng, các cuộc tấn công tràn bộ đệm vẫn thường xuyên xảy ra và gây
hậu quả nghiêm trọng cho hệ thống vì nó có thể can thiệp trực tiếp vào mã nguồn. Tuy
rằng bài viết đã chỉ ra các dạng cơ bản của tấn công Buffer Overflow và các cách
phòng chống nhưng với sự phát triển của công nghệ, các hacker không ngừng phát
triển các cách tấn cơng mới vào hệ thống. Vì vậy, bài viết chỉ có thể giúp người đọc
phần nào biết đến cách tấn công Buffer Overflow và mức độ nguy hiểm của các cuộc
tấn công bằng phương pháp Buffer Overflow.
VI.

TÀI LIỆU THAM KHẢO

 “Kỹ thuật khai thác lỗi tràn bộ đệm”.


Website: />
18