Giới thiệu dự án

Sự bùng nổ của công nghệ thông tin và Internet đã thay đổi toàn diện thói quen kết nối, giải trí và chia sẻ thông tin của người dùng toàn cầu. Theo báo cáo thường niên Digital 2021 từ We Are Social và Hootsuite, hơn 4.2 tỷ người trên thế giới sử dụng mạng xã hội, với thời gian truy cập trung bình vượt 2.5 giờ mỗi ngày. Đồng thời, nghiên cứu từ GlobalWebIndex trên 178,421 người dùng chỉ ra rằng 28% người dùng trong độ tuổi 16–64 chủ động chuyển hướng sang các nền tảng mạng xã hội để tìm kiếm thông tin, thảo luận chuyên sâu và chia sẻ sở thích cá nhân thay vì chỉ dựa vào các công cụ tìm kiếm truyền thống.

Tuy nhiên, các hệ sinh thái mạng xã hội phổ biến hiện nay (như Facebook, Twitter, Reddit) bộc lộ nhiều điểm nghẽn nghiêm trọng:

  • Vấn đề phân mảnh trải nghiệm trên đa thiết bị: Người dùng đòi hỏi trải nghiệm đồng bộ và hiệu năng mượt mà trên cả nền tảng Web, Android và iOS mà không có sự chênh lệch về mặt tính năng.
  • Nguy cơ mất an toàn thông tin cá nhân: Sự gia tăng của các vụ tấn công nghe lén (Eavesdropping) và xâm phạm dữ liệu nhắn tin riêng tư khi các nền tảng không áp dụng mã hóa đầu-cuối hoặc cơ chế phân phối khóa dễ bị tấn công dạng Man-in-the-Middle (MitM).
  • Quá tải thông tin (Information Overload): Thiếu cơ chế lọc và gợi ý bài viết thông minh được may đo theo sở thích cộng đồng khiến luồng tin tức (newsfeed) bị bão hòa, giảm chỉ số tương tác thực (engagement rate).
  • Hạn chế trong tùy biến không gian sinh hoạt: Các cộng đồng chuyên biệt thiếu các công cụ tùy biến giao diện, phân quyền quản trị linh hoạt và phân cấp chế độ truy cập (Public/Private).

Nhằm giải quyết triệt để các bài toán trên, đồ án khóa luận tốt nghiệp kỹ sư ngành An toàn Thông tin (Khoa Mạng máy tính và Truyền thông – Trường Đại học Công nghệ Thông tin, ĐHQG-HCM) đã thực hiện đề tài "Phát triển ứng dụng Mạng Xã Hội đa nền tảng". Đề tài được thực hiện bởi sinh viên Trần Quốc Tuấn (MSSV: 17521226) và Nguyễn Đông Hà (MSSV: 17520418), dưới sự hướng dẫn chuyên môn của ThS. Trần Tuấn Dũng.

+-----------------------------------------------------------------------+
|                       MỤC TIÊU CỐT LÕI CỦA ĐỒ ÁN                      |
+-----------------------------------------------------------------------+
| 1. Xây dựng kiến trúc đa nền tảng: Web (ReactJS) & Mobile (React      |
|    Native cho Android/iOS) với chung một Backend API duy nhất.        |
| 2. Thiết kế hệ thống Backend RESTful hiệu năng cao với Django 3.2     |
|    và Django REST Framework 3.12.                                     |
| 3. Tích hợp hệ thống gợi ý bài viết (Recommendation System) cá nhân   |
|    hóa theo giải thuật Lọc cộng tác người dùng (User-User CF).        |
| 4. Triển khai cơ chế bảo mật tin nhắn trực tuyến thông qua thuật toán  |
|    mật mã Massey-Omura dựa trên giao thức Three-Pass Protocol.        |
| 5. Phát triển hệ thống Chat & Thông báo thời gian thực sử dụng        |
|    WebSockets và Django Channels trên nền tảng ASGI & Redis.          |
+-----------------------------------------------------------------------+

Giải pháp được tiếp cận thông qua việc kết hợp mô hình Client-Server phi trạng thái (stateless) phục vụ REST API với máy chủ xử lý tác vụ bất đồng bộ (asynchronous) hướng sự kiện phục vụ WebSockets. Toàn bộ kiến trúc được tối ưu hóa để đảm bảo độ trễ trao đổi tin nhắn dưới 50ms, khả năng chịu tải hàng nghìn kết nối đồng thời và giảm sai số dự đoán gợi ý bài viết (RMSE) xuống dưới mức 0.90 trên tập dữ liệu kiểm thử.

Phạm vi và giới hạn dự án:

  • Phạm vi nghiên cứu: Xây dựng ứng dụng hoàn chỉnh cho Web và Mobile (Android 8.0+, iOS 12+); triển khai thuật toán Collaborative Filtering; tích hợp mật mã phi đối xứng Massey-Omura cho bảo mật tin nhắn văn bản 1-1; quản lý cộng đồng đa cấp độ.
  • Giới hạn: Hệ sinh thái tập trung xử lý dữ liệu văn bản và đa phương tiện tĩnh (hình ảnh, liên kết); chưa tích hợp cuộc gọi thoại/video mã hóa thời gian thực (WebRTC).

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Khảo sát các giải pháp mạng xã hội đang chiếm lĩnh thị trường cho thấy sự phân hóa rõ rệt về mặt công nghệ, mục đích sử dụng và mức độ bảo mật:

Tiêu chí Facebook Reddit Twitter Giải pháp của Đề tài
Mô hình tổ chức Mạng lưới bạn bè & Trang/Nhóm Hệ thống Subreddit đa tầng Luồng tin tức theo dòng thời gian Cộng đồng chuyên biệt (Community-centric)
Bảo mật tin nhắn Tùy chọn Secret Conversation Không mã hóa E2E tin nhắn riêng Mã hóa giới hạn (Direct Messages) Giao thức 3 bước Massey-Omura
Thuật toán Newsfeed Deep Learning phức tạp, đóng kín Điểm số Upvote/Downvote & Thời gian Hybrid Recommender kết hợp Graph User-User Collaborative Filtering + Ranking
Tùy biến không gian Hạn chế (theo mẫu cố định) Cho phép chỉnh theme cơ bản Chỉ hỗ trợ đổi màu chủ đạo Tùy biến mã màu, banner, chế độ Public/Private
Khả năng đa nền tảng Ứng dụng Native riêng biệt React Native / Native Web + Native Mobile React Native (iOS/Android) + ReactJS (Web)

Hệ thống yêu cầu người dùng được phân loại theo mô hình MoSCoW:

  • Must have: Đăng ký/đăng nhập xác thực JWT, tạo/chỉnh sửa bài viết (Text, Image), tham gia cộng đồng (Public/Private), bình luận đa cấp, Vote bài viết, Chat thời gian thực với mã hóa Massey-Omura, nhận thông báo tức thời.
  • Should have: Gợi ý bài viết thông minh dựa trên User-User Collaborative Filtering, tìm kiếm bài viết/cộng đồng đa tiêu chí, tùy biến giao diện cộng đồng theo mã màu cá nhân.
  • Could have: Đổi ảnh bìa, avatar trực tiếp trên thiết bị di động, bảng điều khiển thống kê tương tác dành cho quản trị viên cộng đồng.
  • Won't have (trong phạm vi giai đoạn này): Livestream video, thanh toán tích hợp ví điện tử, gọi điện thoại mã hóa đầu-cuối.

Thiết kế hệ thống

Kiến trúc hệ thống được thiết kế theo mô hình phân tầng hướng dịch vụ, chia tách rõ ràng giữa lớp hiển thị, lớp điều hướng logic và lớp lưu trữ phân tán.

graph TD
    subgraph Client Layer
        WebClient["ReactJS Web Application"]
        MobileClient["React Native Mobile App (iOS / Android)"]
    end

    subgraph Gateway & Proxy
        Nginx["Nginx Reverse Proxy / SSL Termination"]
    end

    subgraph Application Server
        WSGI["WSGI Server (Gunicorn) - HTTP REST API"]
        ASGI["ASGI Server (Daphne) - WebSocket Handler"]
        DjangoApp["Django Core & Django REST Framework"]
        DjangoChannels["Django Channels Engine"]
    end

    subgraph Processing & Background Services
        RedisEngine["Redis (Channel Layer & In-Memory Cache)"]
        Recommender["Recommendation Worker (User-User CF Engine)"]
    end

    subgraph Persistence Layer
        PostgresDB[(PostgreSQL Database)]
        MediaStorage[("Media File Storage (Static/Media)")]
    end

    WebClient -->|HTTPS REST Request| Nginx
    MobileClient -->|HTTPS REST Request| Nginx
    WebClient -->|WSS Connection| Nginx
    MobileClient -->|WSS Connection| Nginx

    Nginx -->|Proxy HTTP| WSGI
    Nginx -->|Proxy WebSocket| ASGI

    WSGI --> DjangoApp
    ASGI --> DjangoChannels

    DjangoApp --> PostgresDB
    DjangoApp --> MediaStorage
    DjangoChannels --> RedisEngine
    Recommender --> PostgresDB
    DjangoApp --> Recommender

Chi tiết Technology Stack:

  • Backend Framework: Python 3.9, Django 3.2 LTS, Django REST Framework (DRF) 3.12.4
  • Real-time & Asynchronous: Django Channels 3.0.4, ASGI, Daphne 3.0.2, Redis 6.2.4
  • Frontend Web: ReactJS 17.0.2, Redux Toolkit, Axios, TailwindCSS / Material-UI
  • Mobile Application: React Native 0.64.2, React Navigation 5.x, React-Native-WebSocket
  • Database & Persistence: PostgreSQL 13.3, Django ORM
  • Mật mã học: Python Cryptography Toolkit (Massey-Omura implementation over finite fields)

Đặc tả API Endpoints chính:

Phương thức Endpoint URI Chức năng xử lý Xác thực
POST /api/auth/token/ Xác thực người dùng, cấp phát cặp Access/Refresh Token (JWT) Không
GET/POST /api/posts/ Lấy danh sách bài viết theo Feed / Tạo mới bài viết Bắt buộc (POST)
GET /api/posts/recommendations/ Lấy danh sách bài viết được gợi ý theo thuật toán CF Bắt buộc
POST /api/posts/{id}/vote/ Thực hiện Upvote / Downvote bài viết (+1, -1, 0) Bắt buộc
GET/POST /api/communities/ Lấy danh sách hoặc khởi tạo không gian cộng đồng mới Bắt buộc (POST)
WS /ws/chat/{room_id}/ Kênh kết nối WebSocket truyền tải tin nhắn mã hóa Bearer Token
WS /ws/notifications/ Kênh WebSocket lắng nghe sự kiện thông báo thời gian thực Bearer Token

Methodology

Dự án áp dụng quy trình phát triển phần mềm linh hoạt (Agile/Scrum), chia toàn bộ thời gian thực hiện (01/11/2020 – 07/06/2021) thành 7 giai đoạn trọng tâm:

  1. 01/11/2020 – 17/11/2020: Phân tích yêu cầu, khảo sát thị trường và xác định mục tiêu hệ thống.
  2. 17/11/2020 – 11/12/2020: Nghiên cứu công nghệ (React Native, Django Channels, Collaborative Filtering, Massey-Omura).
  3. 12/12/2020 – 26/04/2021: Thiết kế cơ sở dữ liệu, giao diện UI/UX và lập trình hiện thực hóa toàn bộ module hệ thống.
  4. 03/05/2021 – 31/05/2021: Kiểm thử tích hợp (Integration Testing), đánh giá hiệu năng thuật toán và tối ưu hóa hệ thống.
  5. 01/06/2021 – 07/06/2021: Đóng gói sản phẩm, hoàn thiện tài liệu kỹ thuật và báo cáo bảo vệ khóa luận.

Implementation và kết quả

Development process

1. Hệ thống gợi ý bài viết (Collaborative Filtering Recommender)

Hệ thống sử dụng phương pháp User-User Collaborative Filtering dựa trên ma trận tiện ích (Utility Matrix) được chuẩn hóa. Các tương tác như Vote, Comment và View được quy đổi thành điểm đánh giá $R_{u, i}$.

Để giải quyết sự thiên lệch của người dùng khó tính hoặc dễ tính, giá trị đánh giá được chuẩn hóa qua độ lệch chuẩn trung bình: $$\bar{r}u = \frac{1}{|I_u|} \sum{i \in I_u} r_{u,i}$$ $$y_{u,i} = r_{u,i} - \bar{r}_u$$

Độ tương đồng giữa hai người dùng $u_1$ và $u_2$ được tính toán qua hàm Cosine Similarity trên các vector tương tác đã chuẩn hóa: $$\text{sim}(u_1, u_2) = \cos(u_1, u_2) = \frac{u_1 \cdot u_2}{|u_1|2 |u_2|2} = \frac{\sum{i} y{u_1, i} y_{u_2, i}}{\sqrt{\sum_{i} y_{u_1, i}^2} \sqrt{\sum_{i} y_{u_2, i}^2}}$$

Dự đoán mức độ yêu thích của người dùng $u$ đối với bài viết $i$ chưa được đánh giá thông qua $k$ người dùng láng giềng gần nhất ($N(u, i)$): $$\hat{y}{u,i} = \frac{\sum{v \in N(u,i)} \text{sim}(u, v) \cdot y_{v,i}}{\sum_{v \in N(u,i)} |\text{sim}(u, v)|}$$ $$\hat{r}{u,i} = \hat{y}{u,i} + \bar{r}_u$$

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from scipy import sparse

class UserUserCollaborativeFiltering:
    def __init__(self, Y_data, k_neighbors=2):
        """
        Y_data: Ma trận tương tác [user_id, item_id, rating]
        k_neighbors: Số lượng láng giềng gần nhất chọn lọc
        """
        self.Y_data = Y_data
        self.k = k_neighbors
        self.n_users = int(np.max(Y_data[:, 0])) + 1
        self.n_items = int(np.max(Y_data[:, 1])) + 1
        self.mu = np.zeros((self.n_users,))
        self.Ybar_data = None
        self.S = None

    def fit(self):
        # Tính điểm trung bình rating của từng user
        users = self.Y_data[:, 0]
        for u in range(self.n_users):
            ids = np.where(users == u)[0]
            item_ratings = self.Y_data[ids, 2]
            self.mu[u] = np.mean(item_ratings) if len(item_ratings) > 0 else 0

        # Chuẩn hóa ma trận tiện ích (Utility Matrix Normalization)
        self.Ybar_data = self.Y_data.copy()
        for i in range(self.Y_data.shape[0]):
            u = int(self.Y_data[i, 0])
            self.Ybar_data[i, 2] -= self.mu[u]

        # Chuyển đổi sang dạng Sparse Matrix để tối ưu bộ nhớ RAM
        self.Ybar = sparse.coo_matrix(
            (self.Ybar_data[:, 2], (self.Ybar_data[:, 1], self.Ybar_data[:, 0])),
            shape=(self.n_items, self.n_users)
        ).tocsr()

        # Tính toán ma trận độ tương đồng Cosine giữa các user
        self.S = cosine_similarity(self.Ybar.T, self.Ybar.T)

    def predict(self, u, i):
        # Tìm danh sách người dùng đã đánh giá bài viết i
        ids = np.where(self.Y_data[:, 1] == i)[0]
        users_rated_i = (self.Y_data[ids, 0]).astype(np.int32)
        sim = self.S[u, users_rated_i]
        
        # Chọn top k láng giềng có độ tương đồng lớn nhất
        n_neighbors = min(len(users_rated_i), self.k)
        if n_neighbors == 0:
            return self.mu[u]
            
        top_k_idx = np.argsort(sim)[-n_neighbors:]
        nearest_s = sim[top_k_idx]
        rating_normalized = self.Ybar[i, users_rated_i[top_k_idx]].toarray().ravel()
        
        # Tránh chia cho 0
        denominator = np.sum(np.abs(nearest_s)) + 1e-8
        predicted_y = np.sum(nearest_s * rating_normalized) / denominator
        return predicted_y + self.mu[u]

2. Giao thức bảo mật tin nhắn Three-Pass Massey-Omura

Thuật toán Massey-Omura cho phép hai người dùng (Alice và Bob) trao đổi thông điệp mật qua kênh truyền công khai mà không cần chia sẻ trước khóa bí mật hay sử dụng chứng chỉ số công khai (PKI):

  • Cho $p$ là một số nguyên tố lớn được công khai thỏa mãn bài toán logarit rời rạc khó tính toán trên trường $\mathbb{Z}_p^*$.
  • Alice chọn khóa mã hóa bí mật $e_A$ sao cho $\gcd(e_A, p-1) = 1$, tính khóa giải mã $d_A$ thỏa mãn $e_A \cdot d_A \equiv 1 \pmod{p-1}$.
  • Bob chọn khóa mã hóa bí mật $e_B$ sao cho $\gcd(e_B, p-1) = 1$, tính khóa giải mã $d_B$ thỏa mãn $e_B \cdot d_B \equiv 1 \pmod{p-1}$.
Alice (Sender)                                              Bob (Receiver)
  |                                                               |
  |-- [Bước 1: C1 = (M ^ eA) mod p] ----------------------------->|
  |                                                               |-- [Bước 2: C2 = (C1 ^ eB) mod p]
  |<---------------------------- [Bước 2: Gửi C2 về Alice] -------|
  |-- [Bước 3: C3 = (C2 ^ dA) mod p] ---------------------------->|
  |                                                               |-- [Bước 4: M = (C3 ^ dB) mod p]
  |                                                               |   (Giải mã thông điệp gốc)

$$\text{Chứng minh tính đúng đắn: } C_3^{d_B} \equiv (C_2^{d_A})^{d_B} \equiv ((C_1^{e_B})^{d_A})^{d_B} \equiv (((M^{e_A})^{e_B})^{d_A})^{d_B} \equiv M^{e_A d_A e_B d_B} \equiv M^{(1)(1)} \equiv M \pmod p$$

# Minh họa giải thuật mã hóa / giải mã Massey-Omura
def extended_gcd(a, b):
    if a == 0:
        return b, 0, 1
    gcd, x1, y1 = extended_gcd(b % a, a)
    x = y1 - (b // a) * x1
    y = x1
    return gcd, x, y

def mod_inverse(e, phi):
    gcd, x, _ = extended_gcd(e, phi)
    if gcd != 1:
        raise ValueError("Nghịch đảo modulo không tồn tại")
    return (x % phi + phi) % phi

def massey_omura_pass1(M, e_A, p):
    return pow(M, e_A, p)

def massey_omura_pass2(C1, e_B, p):
    return pow(C1, e_B, p)

def massey_omura_pass3(C2, d_A, p):
    return pow(C2, d_A, p)

def massey_omura_extract(C3, d_B, p):
    return pow(C3, d_B, p)

3. Xử lý tin nhắn và thông báo thời gian thực với Django Channels

import json
from channels.generic.websocket import AsyncWebsocketConsumer

class SecureChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.room_name = self.scope['url_route']['kwargs']['room_name']
        self.room_group_name = f'secure_chat_{self.room_name}'

        # Tham gia vào Channel Layer Group
        await self.channel_layer.group_add(
            self.room_group_name,
            self.channel_name
        )
        await self.accept()

    async def disconnect(self, close_code):
        # Rời khỏi Channel Layer Group
        await self.channel_layer.group_discard(
            self.room_group_name,
            self.channel_name
        )

    async def receive(self, text_data):
        payload = json.loads(text_data)
        message_type = payload.get('type')
        encrypted_chunk = payload.get('payload')
        sender_id = self.scope['user'].id

        # Điều phối các bước truyền tải khóa và ciphertext trong giao thức Three-Pass
        await self.channel_layer.group_send(
            self.room_group_name,
            {
                'type': 'chat_message_handler',
                'msg_type': message_type,
                'payload': encrypted_chunk,
                'sender_id': sender_id
            }
        )

    async def chat_message_handler(self, event):
        # Phát dữ liệu mã hóa tới thiết bị đầu cuối
        await self.send(text_data=json.dumps({
            'type': event['msg_type'],
            'payload': event['payload'],
            'sender_id': event['sender_id']
        }))

Testing và validation

Hiệu năng của các thuật toán và hệ thống được kiểm thử thông qua các kịch bản đo lường định lượng cụ thể:

  • Đánh giá sai số thuật toán gợi ý (RMSE - Root Mean Squared Error): $$\text{RMSE} = \sqrt{\frac{1}{|\mathcal{D}{\text{test}}|} \sum{(u, i) \in \mathcal{D}{\text{test}}} (r{u,i} - \hat{r}_{u,i})^2}$$ Thuật toán User-User CF đạt chỉ số $\text{RMSE} = 0.892$ trên tập kiểm thử phân ngẫu nhiên (80% train / 20% test), vượt trội so với mức trung bình baseline $1.145$.
  • Độ trễ truyền tải WebSockets qua Redis Channel Layer:
+-----------------------------------------------------------------------+
|              KẾT QUẢ KIỂM THỬ TẢI HỆ THỐNG REAL-TIME                  |
+-----------------------------------------------------------------------+
| Số lượng kết nối đồng thời (Concurrent WebSockets): 2,000 clients    |
| Thời gian phản hồi trung bình (Average Latency):    32.4 ms           |
| Tỷ lệ gói tin bị trễ hoặc rớt (Packet Loss Rate):   0.00%             |
| Thời gian mã hóa/giải mã trung bình (Massey-Omura): 8.6 ms/packet     |
+-----------------------------------------------------------------------+

Kết quả đạt được

Hệ thống đã hiện thực hóa toàn bộ các module đề ra theo đúng kế hoạch:

  1. Frontend Web & Mobile: Giao diện trực quan, đồng bộ tính năng giữa Web (ReactJS) và Mobile (React Native cho Android/iOS), hỗ trợ tải bài viết dạng Infinite Scroll và bộ lọc Ranking thông minh.
  2. Backend API: Cung cấp đầy đủ 32 REST Endpoints đáp ứng tiêu chuẩn OpenAPI và 2 kênh kết nối WebSocket xử lý tác vụ nền.
  3. An toàn dữ liệu: 100% các cuộc hội thoại riêng tư được bảo vệ thông qua giao thức Massey-Omura 3 bước.

Đổi mới và đóng góp

  • Ứng dụng mật mã học phi đối xứng Massey-Omura vào Chat thời gian thực: Thay vì phụ thuộc vào việc quản lý cặp khóa công khai/khóa bí mật phức tạp qua Certificate Authority (CA), hệ thống áp dụng giao thức Three-Pass Protocol, loại bỏ hoàn toàn nguy cơ rò rỉ khóa bí mật trên đường truyền công khai.
  • Tối ưu hóa tài nguyên xử lý dữ liệu ma trận thưa: Chuyển đổi cấu trúc ma trận tương tác của hệ gợi ý sang định dạng scipy.sparse.csr_matrix, giúp giảm đến 74% dung lượng bộ nhớ RAM tiêu thụ và tăng tốc độ tính toán ma trận Cosine Similarity thêm 3.8 lần so với xử lý trên Dense Matrix thông thường.
  • Cơ chế Customization cộng đồng chuyên sâu: Cho phép người dùng tự khởi tạo và cấu hình không gian thảo luận với bảng màu giao diện độc bản, phân quyền hạn chế theo chế độ Private/Public giúp nâng cao trải nghiệm cá nhân hóa.

Ứng dụng thực tế và triển khai

Kịch bản triển khai thực tế

  1. Mạng xã hội học tập và nghiên cứu nội bộ: Triển khai tại các trường đại học, viện nghiên cứu để sinh viên và giảng viên trao đổi tài liệu, phân nhóm cộng đồng theo từng chuyên ngành, bảo mật các thảo luận nghiên cứu quan trọng.
  2. Nền tảng giao tiếp doanh nghiệp an toàn: Phục vụ các tổ chức đòi hỏi tiêu chuẩn bảo mật dữ liệu cao, loại bỏ rủi ro rò rỉ tin nhắn thông qua máy chủ trung gian.
graph LR
    subgraph Production Deployment Architecture
        Users((Users: Web/Mobile)) -->|SSL/TLS 443| LB[Nginx Reverse Proxy]
        LB -->|Gunicorn Workers| DjangoREST[Django REST API]
        LB -->|Daphne Workers| ASGIWs[Django Channels WS]
        DjangoREST --> DB[(PostgreSQL Master)]
        ASGIWs --> RedisCluster[(Redis Cluster)]
        CeleryWorker[Celery Tasks] --> RedisCluster
        CeleryWorker --> DB
    end

Yêu cầu cấu hình triển khai hệ thống (Minimum System Requirements)

  • Server Backend: CPU 4 Cores, RAM 8GB, SSD 50GB (Ubuntu 20.04 LTS), cài đặt Docker & Docker-Compose.
  • Phần mềm: Python 3.9+, Node.js 14.x+, Redis Server 6.x, PostgreSQL 13.x.
  • Client Mobile: Android 8.0 (API Level 26) trở lên, iOS 12.0 trở lên.

Hạn chế và hướng phát triển

  • Hiện tượng Cold Start: Hệ thống gợi ý Collaborative Filtering chưa đạt hiệu quả tối đa đối với người dùng mới hoặc bài viết mới đăng tải (chưa có tương tác).
    • Hướng giải quyết: Nghiên cứu tích hợp mô hình Hybrid Recommender System, kết hợp Lọc dựa trên nội dung (Content-Based Filtering sử dụng TF-IDF hoặc BERT) với Lọc cộng tác (Collaborative Filtering).
  • Mở rộng bảo mật nhóm chat: Thuật toán Massey-Omura hiện tại được tối ưu hóa cho giao thức trao đổi 1-1; việc mở rộng cho phòng chat nhiều thành viên (Group Chat) làm tăng số lượng bước truyền tải ($O(N)$ passes).
    • Hướng giải quyết: Tích hợp thêm giao thức trao đổi khóa nhóm Tree-based Group Diffie-Hellman (TGDH) hoặc Signal Protocol cho các cuộc trò chuyện đông người.

Đối tượng hưởng lợi

  • Sinh viên chuyên ngành CNTT / An toàn Thông tin: Tài liệu tham khảo thực tế về việc áp dụng thuật toán mật mã phi đối xứng vào ứng dụng thực tiễn và triển khai hệ thống gợi ý từ lý thuyết đến code.
  • Lập trình viên Fullstack & Mobile: Nắm bắt kỹ thuật đồng bộ kiến trúc giữa Django Channels (WebSockets) với React Native trên các thiết bị di động.
  • Doanh nghiệp & Startup: Tiết kiệm hơn 40% chi phí và thời gian phát triển khi tận dụng kiến trúc chia sẻ logic đa nền tảng và bảo mật dữ liệu tối đa.

Câu hỏi thường gặp

1. Yêu cầu kỹ thuật tối thiểu để triển khai hệ thống lên môi trường Production là gì?

Cần máy chủ Linux (Ubuntu 20.04+) tối thiểu 2 vCPU, 4GB RAM, cài đặt Nginx làm Reverse Proxy, Gunicorn chạy WSGI (HTTP), Daphne chạy ASGI (WebSockets) cùng Redis 6.x làm Message Broker.

2. Thuật toán Collaborative Filtering xử lý vấn đề dữ liệu thưa thớt (Sparsity) như thế nào?

Hệ thống sử dụng cấu trúc scipy.sparse.coo_matrix và csr_matrix để chỉ lưu trữ các vị trí có tương tác khác 0, kết hợp chuẩn hóa trừ giá trị trung bình $\bar{r}_u$ để tránh thiên lệch khi tính toán độ tương quan Cosine.

3. Làm thế nào để tích hợp thêm các kênh thông báo đẩy (Push Notifications) ngoài WebSockets?

Hệ thống được thiết kế theo kiến trúc Module; có thể dễ dàng mở rộng thêm Firebase Cloud Messaging (FCM) hoặc Apple Push Notification service (APNs) thông qua Celery Background Tasks khi người dùng ngắt kết nối WebSocket.

4. Thuật toán Massey-Omura có bị tấn công Man-in-the-Middle (MitM) không?

Bản chất giao thức 3 bước thuần túy dễ bị tấn công MitM nếu không có xác thực danh tính. Đề tài khắc phục bằng cách kết hợp chữ ký số và xác thực kênh truyền thông qua JSON Web Token (JWT) đã mã hóa qua HTTPS/WSS.

5. Chi phí vận hành hạ tầng ước tính hàng tháng là bao nhiêu?

Với quy mô 10,000 người dùng hoạt động hàng ngày (DAU), hệ thống có thể vận hành ổn định trên một VPS Cloud (ví dụ: DigitalOcean/AWS) với chi phí ước tính khoảng $40 - $80 USD/tháng.

Kết luận

Khóa luận tốt nghiệp "Phát triển ứng dụng Mạng Xã Hội đa nền tảng" đã giải quyết trọn vẹn bài toán xây dựng nền tảng mạng xã hội hiện đại, an toàn và thông minh. Bằng việc kết hợp sức mạnh xử lý bất đồng bộ của Django Channels, giao diện đa nền tảng linh hoạt của React Native / ReactJS, thuật toán gợi ý User-User Collaborative Filtering chuẩn xác và cơ chế bảo mật tin nhắn Massey-Omura, đề tài mang lại giá trị học thuật cao và khả năng ứng dụng thực tiễn rộng rãi. Hệ thống đã mở ra một hướng đi mới trong việc phát triển các cộng đồng trực tuyến tự chủ, an toàn thông tin và cá nhân hóa trải nghiệm người dùng.