Báo cáo đồ án cơ sở ngành mạng phần nguyên lý hệ điều hành tìm hiểu về lập trình hook và xây dựng chương trình keylogger đơn giản phần lập trình mạng xây dựng game ai là triệu phú

ĐẠI HỌC ĐÀ NẴNG
TRƯỜNG ĐẠI HỌC BÁCH KHOA

KHOA CÔNG NGHỆ THÔNG TIN
-----🙞🙞🙞🙞🙞-----

BÁO CÁO ĐỒ ÁN
CƠ SỞ NGÀNH MẠNG
Phần Nguyên lý hệ điều hành:Tìm hiểu về lập trình Hook

và Xây dựng chương trình Keylogger đơn giản.
Phần Lập trình mạng: Xây dựng game Ai là triệu phú.


MỤC LỤC
DANH SÁCH HÌNH VẼ...........................................................................................4
DANH SÁCH CÁC TỪ VIẾT TẮT..........................................................................4
MỞ ĐẦU................................................................................................................... 5
PHẦN 1: NGUYÊN LÝ HỆ ĐIỀU HÀNH...............................................................6
CHƯƠNG 1: CƠ SỞ LÝ THUYẾT......................................................................6
1.1 Thông điệp và hàng đợi thông điệp..............................................................6
1.1.1 Giới thiệu về thông điệp và hàng đợi thông điệp..................................6
1.1.2 Sử dụng thông điệp và hàng đợi thông điệp..........................................8
1.2 Kỹ thuật Hook.............................................................................................9
1.2.1 Tổng quan về Hook..............................................................................9
1.2.2 Các hàm thường dùng.........................................................................10
1.2.3 Sử dụng Hook.....................................................................................11
CHƯƠNG 2: PHÂN TÍCH VÀ THIẾT KẾ HỆ THỒNG...................................12
2.1 Phân tích yêu cầu.......................................................................................12
2.1.1 Yêu cầu về chức năng.........................................................................12
2.1.2 Yêu cầu về giao diện người dùng........................................................12

2.1.3 Yêu cầu về tương thích.......................................................................12
2.2 Phân tích chức năng...................................................................................12
a) Chức năng chạy ẩn ứng dụng...............................................................12
b) Bắt sự kiện từ bàn phím.......................................................................13
c) Ghi ra tệp văn bản theo ngày tháng, theo từng ứng dụng.....................13
CHƯƠNG 3: TRIỂN KHAI VÀ ĐÁNH GIÁ KẾT QUẢ...................................14
3.1 Môi trường triển khai.................................................................................14
3.2 Kết quả giao diện một số chức năng chương trình.....................................14
3.3 Đánh giá và nhận xét.................................................................................16
KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN...........................................................16
Những kết quả đạt được...................................................................................16
Những vấn đề còn tồn lại.................................................................................16
Hướng phát triển..............................................................................................16
PHẦN 2: LẬP TRÌNH MẠNG...............................................................................17
CHƯƠNG 1: CƠ SỞ LÝ THUYẾT....................................................................17


1.1 Giao thức TCP/IP......................................................................................17
1.2 Socket và Port............................................................................................17
1.3 Mơ hình Client/Server...............................................................................18
1.3.1 Giới thiệu............................................................................................18
1.3.2 Mơ hình truyền tin Client/Server........................................................19
CHƯƠNG 2: PHÂN TÍCH VÀ THIẾT KẾ HỆ THỐNG...................................19
2.1 Phân tích yêu cầu.......................................................................................19
2.1.1 Yêu cầu về chức năng.........................................................................19
2.1.2 Yêu cầu về tương thích.......................................................................19
2.2 Thiết kế hệ thống.......................................................................................20
a) Sơ đồ Use-Case....................................................................................20
b) Sơ đồ lớp.............................................................................................20
CHƯƠNG 3: TRIỂN KHAI VÀ ĐÁNH GIÁ KẾT QUẢ...................................21

3.1 Môi trường triển khai.................................................................................21
3.2 Kết quả giao diện một số chức năng chương trình.....................................21
3.3 Đánh giá và nhận xét.................................................................................24
KẾT LUẬN CHUNG......................................................................................25


DANH SÁCH HÌNH VẼ
Hình 1.1: Mơ tả bắt sự kiện từ bàn phím
Hình 1.2: Kết quả ghi lại mã ASCII của các phím đã gõ
Hình 1.3: Kết quả file.txt ghi lại các phím đã gõ
Hình 2.1: Mơ hình truyền tin Client/Server
Hình 2.2: Sơ đồ Use-Case
Hình 2.3: Sơ đồ lớp
Hình 2.4: Giao diện khi chạy Server
Hình 2.5: Giao diện khi chạy Client
Hình 2.6: Giao diện khi Client đăng nhập thành cơng
Hình 2.7: Giao diện chính của game
Hình 2.8: Giao diện khi nhấn nút “?”- hướng dẫn chơi game
Hình 2.9: Giao diện khi chơi game

DANH SÁCH CÁC TỪ VIẾT TẮT

Từ viết tắt
TCP/IP
MS-DOS
DLL
IDE

Diễn giải
Transmission Control Protocol/Internet Protocol

Microsoft Disk Operating System
Dynamic Link Library
Integrated Development Environment


MỞ ĐẦU
Đồ án Cơ sở ngành Mạng là học phần rất quan trọng trong quá trình học tập
của sinh viên. Đồ án này giúp sinh viên tiếp cận và rèn luyện các kiến thức, kỹ năng
liên quan đến Môn học Ngun lý hệ điều hành và Lập trình mạng.
Trong khn khổ đồ án, dưới sự hướng dẫn của Nguyễn Tấn Khơi, em đã chọn
đề tài Xây dựng chương trình Keylogger đơn giản cho phần nguyên lý hệ điều hành
và Xây dựng game “Ai là triệu phú” chơi qua mạng cho phần lập trình mạng.
Thơng qua đề tài này, em đã hiểu rõ hơn phần nào về nguyên lý hoạt động xử lý
thông điệp của hệ điều hành cũng như là biết được cách lập trình với giao thức
TCP/IP theo mơ hình Client/Server.
Do thời gian và kiến thức của em cịn hạn chế nên khơng tránh khỏi những sai
sót nhất định trong quá trình làm đồ án này. Rất mong nhận được sự góp ý của q
thầy cơ.
Em xin chân thành cảm ơn!


PHẦN 1: NGUYÊN LÝ HỆ ĐIỀU HÀNH
TIÊU ĐỀ: XÂY DỰNG CHƯƠNG TRÌNH KEYLOGGER ĐƠN GIẢN
CHƯƠNG 1: CƠ SỞ LÝ THUYẾT
1.1 Thông điệp và hàng đợi thông điệp
1.1.1 Giới thiệu về thông điệp và hàng đợi thông điệp
Không giống như các ứng dụng trên nền MS-DOS, các ứng dụng trên nền
Windows thì hướng sự kiện, chúng khơng thực hiện các cuộc gọi hàm rõ ràng để lấy
đầu vào, thay vào đó chúng chờ cho hệ thống chuyển đầu vào đến chúng.

a) Thông điệp windows
Hệ thống chuyển đầu vào cho một thủ tục cửa sổ dưới dạng thông điệp. Thông
điệp được tạo bởi cả hệ thống và ứng dụng. Hệ thống tạo ra một thông điệp tại mỗi
sự kiện đầu. Hệ thống cũng tạo ra các thông điệp để đáp ứng với những thay đổi
trong hệ thống do ứng dụng gây ra. Một ứng dụng có thể tạo ra các thơng điệp đến
trực tiếp các cửa sổ riêng để thực thi các tác vụ hoặc để giao tiếp với các cửa sổ
trong ứng dụng khác.
Hệ thống gửi một thông điệp đến một thủ tục cửa sổ với một bộ gồm bốn tham
số: một cửa sổ xử lý, một định danh thông điệp, và hai giá trị được gọi là thông số
thông điệp.

b) Các loại thông điệp
 Thông điệp do hệ thống xác định
Hệ thống gửi hoặc đăng một thông điệp do hệ thống xác định khi nó giao tiếp với
một ứng dụng. Nó sử dụng các thơng điệp này để kiểm sốt các hoạt động của các
ứng dụng và cung cấp đầu vào và các thông tin khác cho các ứng dụng để xử lý.
Ứng dụng cũng có thể gửi hoặc đăng các thông điệp do hệ thống xác định. Các ứng
dụng thường sử dụng các thơng điệp này để kiểm sốt hoạt động của các cửa sổ
điều khiển được tạo ra bằng cách sử dụng các lớp cửa sổ được đăng ký trước.

 Thông điệp do ứng dụng xác định
Một ứng dụng có thể tạo các thơng điệp để được sử dụng bởi các cửa sổ riêng
của chính nó hoặc để giao tiếp với các cửa sổ trong các tiến trình khác.

c) Định tuyến thông điệp
Hệ thống sử dụng hai phương pháp để định tuyến thông điệp đến một thủ tục cửa
sổ: đăng thông điệp vào hàng đợi được gọi là hàng đợi thông điệp, một đối tượng bộ


nhớ do hệ thống xác định lưu trữ thông điệp tạm thời và gửi thông điệp trực tiếp đến

thủ tục cửa sổ.

 Thơng điệp được xếp hàng đợi
Hệ thống có thể hiển thị bất kỳ cửa số nào tại một thời điểm. Để định tuyến đầu
vào chuột và bàn phím đến cửa sổ thích hợp, hệ thống sử dụng hàng đợi thông điệp.

 Thông điệp không xếp hàng đợi
Các thông điệp không xếp hàng đợi được gửi đi ngay lập tức đến thủ tục cửa sổ
đích, bỏ qua hàng đợi thông điệp hệ thống và hàng đợi thông điệp luồng. Hệ thống
thông điệp gửi các thông điệp không xếp hàng đợi để báo cho một cửa sổ các sự
kiện có ảnh hưởng đến nó.

d) Xử lý thơng điệp
Một ứng dụng phải loại bỏ và xử lý các thông điệp được đăng đến hàng đợi thơng
điệp của luồng của nó. Một ứng dụng đơn luồng thơng điệp sử dụng một vịng lặp
thơng điệp trong hàm WinMain của nó để loại bỏ và gửi thơng điệp đến các thủ tục
cửa sổ thích hợp để xử lý. Các ứng dụng có nhiều luồng có thể bao gồm một vịng
lặp thơng điệp trong mỗi luồng tạo ra một cửa sổ.

 Vịng lặp thơng điệp
Một vịng lặp thơng điệp đơn giản bao gồm một cuộc gọi hàm tới một trong ba
hàm sau: GetMessage, TranslateMessage và DispatchMessage. Lưu ý rằng nếu có
lỗi, GetMessage trả về –1, do đó cần có sự kiểm tra đặc biệt.
Hàm GetMessage lấy một thông điệp từ hàng đợi và sao chép nó vào một cấu
trúc kiểu MSG. Nó trả về một giá trị nonzero, trừ khi nó gặp thơng điệp
WM_QUIT, trong trường hợp này nó trả về FALSE và kết thúc vòng lặp. Trong
một ứng dụng đơn luồng, kết thúc vòng lặp thơng điệp thường là bước đầu tiên
trong việc đóng ứng dụng. Một ứng dụng có thể kết thúc vịng lặp của riêng nó bằng
cách sử dụng hàm PostQuitMessage, thơng điệp phản hồi với thông điệp
WM_DESTROY trong thủ tục cửa sổ của cửa sổ chính của ứng dụng.

Một vịng lặp thông điệp của luồng phải bao gồm TranslateMessage nếu luồng đó
dùng để nhận đầu vào ký tự từ bàn phím. Hệ thống tạo các thơng điệp phím ảo
(WM_KEYDOWN và WM_KEYUP) mỗi lần người dùng nhấn một phím. Một
thơng điệp phím ảo chứa mã phím ảo xác định phím nào được nhấn, nhưng khơng
có giá trị ký tự. Để lấy giá trị này, vịng lặp thơng điệp phải chứa TranslateMessage,
thơng dịch thơng điệp phím ảo thành một thơng điệp ký tự (WM_CHAR) và đặt nó
trở lại hàng đợi thơng điệp ứng dụng. Thơng điệp ký tự sau đó có thể được xóa bỏ
khi một lần lặp tiếp theo của vịng lặp thông điệp và gửi đến một thủ tục cửa sổ.


Chỉ cần một vịng lặp thơng điệp cho một hàng đợi thơng điệp, ngay cả khi một
ứng dụng có chứa nhiều cửa sổ. DispatchMessage luôn gửi thông điệp đến cửa sổ
thích hợp; điều này là bởi vì mỗi thơng điệp trong hàng đợi là một cấu trúc MSG có
chứa các xử lý của cửa sổ mà thông điệp thuộc về.

 Thủ tục cửa sổ
Một thủ tục cửa sổ là một hàm nhận và xử lý tất cả các thông điệp được gửi đến
cửa sổ đó. Mỗi lớp cửa sổ có một thủ tục cửa sổ, và mỗi cửa sổ được tạo ra với lớp
đó sử dụng cùng một thủ tục cửa sổ để trả lời các thông điệp.
Hệ thống sẽ gửi một thông điệp đến một thủ tục cửa sổ bằng cách chuyển dữ liệu
thông điệp làm đối số cho thủ tục. Các thủ tục cửa sổ sau đó thực hiện một hành
động thích hợp cho thơng điệp; nó kiểm tra mã nhận dạng thông điệp, trong khi xử
lý thông điệp, sử dụng thông tin được quy định bởi các tham số thông điệp.
1.1.2 Sử dụng thông điệp và hàng đợi thơng điệp

a) Tạo vịng lặp thơng điệp
Hệ thống khơng tự động tạo hàng đợi thông điệp cho mỗi luồng. Thay vào đó, hệ
thống tạo ra một hàng đợi thơng điệp duy nhất cho các luồng thực hiện các thao tác
yêu cầu một hàng đợi thông điệp. Nếu luồng tạo một hoặc nhiều cửa sổ, phải cung
cấp vịng lặp thơng điệp; vịng lặp thơng điệp này lấy thơng điệp từ hàng đợi thông

điệp của luồng và gửi chúng đến các thủ tục cửa sổ thích hợp.
Bởi vì hệ thống hướng các thông điệp đến các cửa sổ riêng lẻ trong một ứng
dụng, nên một luồng phải tạo ít nhất một cửa sổ trước khi bắt đầu vịng lặp thơng
điệp của nó. Hầu hết các ứng dụng có chứa một luồng đơn tạo ra các cửa sổ. Một
ứng dụng đặc thù đăng ký lớp cửa sổ cho cửa sổ chính của nó, tạo và hiển thị cửa sổ
chính, và sau đó bắt đầu vịng lặp thơng điệp của nó - tất cả trong hàm WinMain.

b) Kiểm tra hàng đợi thông điệp
Thỉnh thoảng, một ứng dụng cần kiểm tra nội dung của hàng đợi thơng điệp của
một luồng từ bên ngồi vịng lặp thông điệp của luồng. Trừ khi ứng dụng định kỳ
kiểm tra hàng đợi thơng điệp trong q trình hoạt động đối với các thơng điệp chuột
và bàn phím, nó sẽ không phản hồi lại đầu vào của người dùng cho đến sau khi thao
tác hoàn tất. Lý do cho điều này là hàm DispatchMessage trong vịng lặp thơng điệp
của luồng không trả về cho đến khi thủ tục cửa sổ kết thúc xử lý một thông điệp.


c) Đăng thơng điệp
Bạn có thể đăng thơng điệp lên hàng đợi thông điệp bằng cách sử dụng hàm
PostMessage. PostMessage đặt một thông điệp ở cuối hàng đợi thông điệp của một
luồng và trả về ngay lập tức mà không cần đợi luồng xử lý thông điệp.

d) Gửi thông điệp
Hàm SendMessage được sử dụng để gửi thông điệp trực tiếp đến một thủ tục cửa
sổ. SendMessage gọi thủ tục cửa sổ và đợi thủ tục đó xử lý thơng điệp và trả lại kết
quả.
1.2 Kỹ thuật Hook
1.2.1 Tổng quan về Hook
Một hook là một cơ chế mà một ứng dụng có thể chặn các sự kiện, chẳng hạn
như các thơng điệp, các hoạt động của chuột và các phím. Một hàm chặn một loại
sự kiện cụ thể được gọi là thủ tục hook. Một thủ tục hook có thể hành động trên mỗi

sự kiện nó nhận được, và sau đó sửa đổi hoặc loại bỏ sự kiện.

a) Chuỗi Hook
Hệ thống hỗ trợ nhiều kiểu hook khác nhau; mỗi loại cung cấp quyền truy cập
vào một khía cạnh khác nhau của cơ chế xử lý thơng điệp của nó. Ví dụ, một ứng
dụng có thể sử dụng hook WH_MOUSE để theo dõi lưu lượng thông điệp cho
thông điệp chuột.
Hệ thống duy trì một chuỗi hook riêng biệt cho từng loại hook. Một chuỗi hook
là một danh sách các con trỏ tới các hàm gọi lại đặc biệt, được ứng dụng định nghĩa
được gọi là các thủ tục hook. Khi một thông điệp xảy ra được liên kết với một loại
hook cụ thể, hệ thống sẽ truyền thông điệp đến từng thủ tục hook được tham chiếu
trong chuỗi hook, cái này sau cái kia. Tác động của một thủ tục hook có thể phụ
thuộc vào độc phức tạp của loại hook. Các thủ tục hook cho một số loại hook chỉ có
thể theo dõi thơng điệp; những loại khác có thể sửa đổi thơng điệp hoặc ngừng tiến
trình của nó thơng qua chuỗi, ngăn cản thông điệp tiếp cận thủ tục hook tiếp theo
hoặc cửa sổ đích.

b) Thủ tục Hook
Thủ tục hook phải có cú pháp sau:
LRESULT CALLBACK HookProc(
int nCode,
WPARAM wParam,


LPARAM lParam
){
// process event…
return CallNextHookEx(NULL, nCode, wParam, lParam);
}

HookProc là một sự giữ chỗ cho tên một ứng dụng được định nghĩa.
Tham số nCode là một mã hook mà thủ tục hook sử dụng để xác định hành động
để thực hiện. Giá trị của mã hook phụ thuộc vào loại hook; mỗi loại có bộ mã hook
đặc trưng riêng. Các giá trị của các tham số wParam và lParam phụ thuộc vào mã
hook, nhưng chúng đặc thù chứa thông tin về một thông điệp được gửi hoặc được
đăng.

c) Các kiểu Hook
Mỗi một kiểu Hook cho phép ứng dụng điều khiển thông điệp theo những cách
khác nhau trong kỹ thuật điều khiển thông điệp (message-handling mechanism).
Dưới đây là những kiểu hook khác nhau: WH_KEYBOARD,
WH_KEYBOARD_LL, WH_MOUSE, WH_MOUSE_LL…và một số kiểu Hook
khác.
1.2.2 Các hàm thường dùng

a) SetWindowsHookEx
HHOOK WINAPI SetWindowsHookEx(
__in int idHook,
__in HOOKPROC lpfn,
__in HINSTANCE hMod,
__in DWORD dwThreadId
);

b) UnhookWindowsHookEx
BOOL WINAPI UnhookWindowsHookEx(
__in HHOOK hhk
);


c) CallNextHookEx

LRESULT WINAPI CallNextHookEx(
__in_opt HHOOK hhk,
__in int nCode,
__in WPARAM wParam,
__in LPARAM lParam
);

d) LowLevelKeyboardProc
LRESULT CALLBACK LowLevelKeyboardProc(
__in int nCode,
__in WPARAM wParam,
__in LPARAM lParam
);
1.2.3 Sử dụng Hook
Có thể cài đặt một thủ tục hook bằng cách gọi hàm SetWindowsHookEx và chỉ
rõ kiểu của thủ tục gọi hook, cho dù thủ tục nên được liên kết với tất cả các luồng
trong cùng một máy tính như là luồng gọi hoặc với một luồng cụ thể và một con trỏ
đến đầu vào thủ tục.
Bạn phải đặt một thủ tục hook toàn cục trong một DLL riêng biệt từ ứng dụng cài
đặt thủ tục hook. Ứng dụng cài đặt phải có xử lý cho mơ-đun DLL trước khi nó có
thể cài đặt thủ tục hook. Để lấy một xử lý đến module DLL, hãy gọi hàm
LoadLibrary với tên của DLL. Sau khi đã có được xử lý, có thể gọi hàm
GetProcAddress để lấy một con trỏ đến thủ tục hook. Cuối cùng, sử dụng
SetWindowsHookEx để cài đặt địa chỉ thủ tục hook trong chuỗi hook thích hợp.
SetWindowsHookEx chuyển mô-đun xử lý, con trỏ tới điểm nhập thủ tục hook và 0
cho luồng định danh, chỉ ra rằng thủ tục hook phải được liên kết với tất cả các luồng
trong cùng một màn hình với tư cách là luồng gọi.
Bạn có thể giải phóng một luồng thủ tục hook (loại bỏ địa chỉ của nó khỏi chuỗi
hook) bằng cách gọi hàm UnhookWindowsHookEx, chỉ định xử lý cho thủ tục hook
để giải phóng. Giải phóng một thủ tục hook ngay sau khi ứng dụng của bạn khơng

cịn cần đến nó nữa.


CHƯƠNG 2: PHÂN TÍCH VÀ THIẾT KẾ HỆ THỒNG
2.1 Phân tích u cầu
2.1.1 u cầu về chức năng
Chương trình ghi lại tồn bộ thao tác phím của người dùng và lưu ra một tập tin
văn bản.
2.1.2 Yêu cầu về giao diện người dùng
2.1.3 Yêu cầu về tương thích
Để đảm bảo có sự tương tác tốt nhất với Windows, trong chương trình này em đã
sử dụng ngơn ngữ C++ trên mơi trường DevC++.
2.2 Phân tích chức năng
Keylogger sẽ có một số chức năng chính như sau:

a) Bắt sự kiện từ bàn phím.
Cơ chế bắt sự kiện từ bàn phím được mơ tả như sau: khi có sự kiện nhấn phím từ
người dùng, thông điệp sẽ được truyền đến chuỗi hook được liên kết với thơng điệp
đó, thơng điệp sẽ được xử lý lần lượt tại mỗi thủ tục hook trong chuỗi hook.

Hình 1.1: Mơ tả bắt sự kiện từ bàn phím

b) Ghi ra tệp văn bản theo ngày tháng, theo từng ứng dụng.
Khi người dùng nhấn phím, thì ứng dụng cũng đồng thời bắt phím và ghi phím
đó ra tệp. Tệp ghi ra theo từng ngày tháng cụ thể và tương ứng với ứng dụng tương
tác.


CHƯƠNG 3: TRIỂN KHAI VÀ ĐÁNH GIÁ KẾT QUẢ
3.1 Môi trường triển khai

Chương trình được triển khai chạy thử nghiệm trong môi trường Windows 10
3.2 Kết quả giao diện một số chức năng chương trình

Hình 1.2: Kết quả hiện thị Mã ASCII của các phím đã gõ


Hình 1.3: Kết quả file.txt ghi lại các phím đã gõ


3.3 Đánh giá và nhận xét
Sau khi triển khai và chạy thử ứng dụng, em đã rút ra các nhận xét đánh giá sau:
 Chương trình khơng làm tăng đáng kể thời gian hiển thị phím bấm.
 Chương trình ghi lại được 100% thao tác phím.
 Các tập tin ghi lại theo ngày tháng và ứng dụng mà người dùng gõ chính xác
hồn tồn.
 Chương trình sẽ hoạt động khơng chính xác nếu có các ứng dụng hook khác
như các chương trình gõ tiếng việt (Unikey, Vietkey…).

KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN
Những kết quả đạt được
 Chương trình ghi lại 100% thao tác phím.
 Các tập tin ghi lại theo ngày và tên ứng dụng mà người dùng gõ phím thơng
tin chính xác 100%.
Những vấn đề cịn tồn lại
 Có các tự lạ trong bản Log. Nguyên nhân là do các ký tự Unicode do chương
trình Unicode (Unikey, Vietkey) gửi đến.
Hướng phát triển







Cho phép hiển thị Unicode trong bản log.
Mã hóa các tập tin log để người sử dụng khơng biết được là đang bị theo dõi.
Kết hợp gửi thông tin về mail.
Thiết kế bổ sung thêm phần giao diện.
Vì đây là ứng dụng mang tính đánh cắp thơng tin người khác nên cần chạy
ẩn.


PHẦN 2: LẬP TRÌNH MẠNG
TIÊU ĐỀ: XÂY DỰNG GAME “AI LÀ TRIỆU PHÚ”
CHƯƠNG 1: CƠ SỞ LÝ THUYẾT
1.1 Giao thức TCP/IP
TCP/IP là viết tắt của cụm từ Transmission Control Protocol/Internet Protocol.
TCP/IP là tập hợp các giao thức (protocol) điều khiển truyền thông giữa tất cả các
máy trên Internet.Cụ thể hơn, TCP/IP chỉ rõ cách thức đóng gói thơng tin (hay cịn
gọi là gói tin), được gửi và nhận các máy tính có kết nối với nhau. TCP/IP được
phát triển năm 1978 bởi Bob Kahn và Vint Ceft.
Ngày nay TCP/IP được sử dụng rộng rãi trong mạng cục bộ cũng như mạng tồn
cầu. TCP/IP được xem như giản lược của mơ hình tham chiếu OSI với 4 tầng ứng
dụng như sau:
- Tầng liên kết (Datalink Layer)
- Tầng mạng (Internet Layer)
- Tầng giao vận (Transport Layer)
- Tầng ứng dụng (Application Layer)
1.2 Socket và Port
Socket: có thể gọi là một ổ kết nối hay một điểm kết nối cho các ứng dụng
thông tin với nhau.

Đây là một khái niệm trừu tượng (Không vật lý) trong lý thuyết mạng, thuộc về
phần mềm. Một điểm kết nối (socket) là một kết hợp giữa địa chỉ ip và một cổng kết
nối (port). Với khái niệm này, các ứng dụng có thể thơng tin với nhau trên cùng một
máy tính, hoặc là trên các máy tính khác nhau trên mạng LAN, mạng internet. Một
khái niệm không thể thiếu khi sử dụng socket đó là giao thức (protocol),các ứng
dụng thông thường trao đổi thông tin, dữ liệu qua giao thức.
Cổng (Port): có thể gọi là một cổng kết nối cho mạng thơng tin, mạng internet.
Cổng kết nối có thể là một cổng thực, vật lý. Tuy nhiên trong lý thuyết mạng cổng
kết nối có thể là khái niệm trừu tượng, đánh số từ 0 đến 65535, được dùng trong các
lớp phần mềm (khơng vật lý), ví dụ cổng kết nối 8080 cho web browser, cổng kết
nối 80 cho web server v.v. Lý do người ta phát minh ra cái khái niệm trừu tượng
này là vì có thể có nhiều ứng dụng cùng dùng chung một cổng vật lý, ví dụ có nhiều
ứng dụng dùng cổng card mạng: email, browser, ..v.v. Để tránh nhầm lẫn với nhau,
mỗi ứng dụng phải dùng riêng ổ kết nối (socket), dùng riêng giao thức (protocol).


1.3 Mơ hình Client/Server
1.3.1 Giới thiệu
Mơ hình được phổ biến nhất và được chấp nhận rộng rãi trong các hệ thống
phân tán là mơ hình client/server. Trong mơ hình này sẽ có một tập các tiến trình
mà mỗi tiến trình đóng vai trị như là một trình quản lý tài nguyên cho một tập hợp
các tài nguyên cho trước và một tập hợp các tiến trình client trong đó mỗi tiến trình
thực hiện một tác vụ nào đó cần truy xuất tới tài nguyên phần cứng hoặc phần mềm
dùng chung. Bản thân các trình quản lý tài nguyên cần phải truy xuất tới các tài
nguyên dùng chung được quản lý bởi một tiến trình khác, vì vậy một số tiến trình
vừa là tiến trình client vừa là tiến trình server. Các tiến trình phát ra các yêu cầu tới
các server bất kỳ khi nào chúng cần truy xuất tới một trong các tài nguyên của các
server. Nếu yêu cầu là đúng đắn thì server sẽ thực hiện hành động được yêu cầu và
gửi một đáp ứng trả lời tới tiến trình client.
Mơ hình client/server cung cấp một cách tiếp cận tổng quát để chia sẻ tài

nguyên trong các hệ thống phân tán. Mơ hình này có thể được cài đặt bằng rất nhiều
môi trường phần cứng và phần mềm khác nhau. Các máy tính được sử dụng để chạy
các tiến trình client/server có nhiều kiểu khác nhau và khơng cần thiết phải phân
biệt giữa chúng; cả tiến trình client và tiến trình server đều có thể chạy trên cùng
một máy tính. Một tiến trình server có thể sử dụng dịch vụ của một server khác.
Mơ hình truyền tin client/server hướng tới việc cung cấp dịch vụ. Quá trình
trao đổi dữ liệu bao gồm:
1. Truyền một yêu cầu từ tiến trình client tới tiến trình server
2. Yêu cầu được server xử lý
3. Truyền đáp ứng cho client


1.3.2 Mơ hình truyền tin Client/Server
Server

Client

Socket()

1

Socket()

Bind()

2

Bind()

Listen()

3
4

Connect()

Accept()

5

Các ch ức
năng gửi
và nhận

6

Các chức
năng gửi
và nhận

Close()

7

Close()

Hình 2.1: Mơ hình truyền tin Client/Server

CHƯƠNG 2: PHÂN TÍCH VÀ THIẾT KẾ HỆ THỐNG
2.1 Phân tích u cầu

2.1.1 Yêu cầu về chức năng
Game “Ai là triệu phú” cho phép người chơi là các client có thể đăng nhập vào hệ
thống để tham gia chơi trả lời các câu hỏi khi server đã được bật lên.
2.1.2 Yêu cầu về tương thích
Chương trình được xây dựng bằng ngơn ngữ lập trình Java trên mơi trường
NetBeans IDE8.2
Cơ sở dữ liệu được lưu trong MySQL.


2.2 Thiết kế hệ thống

a) Sơ đồ Use-Case

Hình 2.2: Sơ đồ Use-Case

b) Sơ đồ lớp

Hình 2.3: Sơ đồ lớp


CHƯƠNG 3: TRIỂN KHAI VÀ ĐÁNH GIÁ KẾT QUẢ
3.1 Môi trường triển khai
Chương trình được triển khai chạy thử nghiệm trong môi trường NetBeans
3.2 Kết quả giao diện một số chức năng chương trình

Hình 2.4: Giao diện khi chạy Server

Hình 2.5: Giao diện khi chạy Client