👋 Chào mừng đến với Nocoem — kiến thức Backend, System Design và lập trình. Khám phá ngay

API Security Best Practices - OAuth

TL;DR: Bốn lỗi OAuth hay gặp nhất khi bạn tự dựng máy chủ ủy quyền (authorization server) hoặc tích hợp OAuth cho ứng dụng của mình:
  • Không xác thực chặt redirect_uri ở phía máy chủ.
  • Vẫn dùng luồng cấp quyền ngầm định (implicit grant) qua response_type=token.
  • Bỏ qua tham số state, hở cửa cho tấn công CSRF.
  • Không giới hạn và xác thực phạm vi (scope) theo từng ứng dụng khách.
Sửa cả bốn điểm này, OAuth flow của bạn đã an toàn hơn phần lớn hệ thống ngoài kia.

Bạn tích hợp "Đăng nhập bằng Google" hoặc tự dựng máy chủ ủy quyền OAuth cho hệ thống microservice nội bộ, chạy thử thấy đăng nhập mượt là thường coi như xong việc. Vấn đề là chuẩn OAuth 2.0 (RFC 6749) chỉ định nghĩa "đường đi đúng"; còn việc chặn "đường đi sai" lại là việc của bạn. Rất nhiều lỗ hổng OAuth từng được công bố (chiếm quyền qua chuyển hướng mở, đánh cắp access token lộ trên URL) đều xuất phát từ việc bỏ qua vài dòng kiểm tra tưởng chừng không quan trọng.

Trước khi vào từng lỗi cụ thể, tôi nhắc nhanh luồng OAuth phổ biến và an toàn nhất hiện nay: luồng cấp mã ủy quyền (authorization code grant).

May chu uy quyen (authorization server) Trinh duyet (nguoi dung) Ung dung khach (client server) 1 2 3 4
1: trình duyệt mở trang /authorize kèm redirect_uri, state, scope. 2: máy chủ ủy quyền chuyển hướng trình duyệt về redirect_uri kèm code và state. 3: trình duyệt chạm tới ứng dụng khách cùng code và state. 4: ứng dụng khách gửi code qua kênh server-to-server (không qua trình duyệt) để đổi lấy access token.

Điểm mấu chốt: với luồng này, access token không bao giờ đi qua trình duyệt. Thứ duy nhất lộ ra ngoài là mã ủy quyền (authorization code) - một chuỗi dùng một lần, sống rất ngắn (thường vài chục giây). Bốn thực hành tốt bên dưới đều nhằm giữ cho từng bước trong sơ đồ này không bị lợi dụng.

1. Luôn xác thực redirect_uri ở phía máy chủ

redirect_uri là tham số chỉ định địa chỉ (URI) mà máy chủ ủy quyền sẽ chuyển hướng trình duyệt về sau khi người dùng đồng ý cấp quyền, kèm theo mã ủy quyền hoặc access token. Nói cách khác, đây chính là "địa chỉ giao hàng" cho thứ nhạy cảm nhất trong cả luồng OAuth.

Nếu máy chủ ủy quyền không kiểm tra redirect_uri chặt chẽ, kẻ tấn công có thể tự sửa tham số này thành một trang do họ kiểm soát. Người dùng vẫn đăng nhập bình thường, nhưng mã ủy quyền (hoặc tệ hơn, access token) lại bị chuyển thẳng tới máy chủ của kẻ tấn công. Đây là dạng tấn công chuyển hướng mở (open redirect) áp dụng lên OAuth, và nó cũng mở đường cho giả mạo yêu cầu liên trang (CSRF) hay các trang lừa đảo (phishing) mạo danh trang đăng nhập thật.

Cách phòng đơn giản nhưng hay bị làm sai: nhiều người kiểm tra bằng startsWith() hoặc so khớp một phần chuỗi, tưởng vậy là an toàn.

// Sai: chỉ kiểm tra "có bắt đầu bằng domain của tôi"
function isValidRedirect(uri) {
  return uri.startsWith('https://myapp.com');
}

// Kẻ tấn công đăng ký domain phụ, ví dụ:
// https://myapp.com.attacker.io/callback
// Chuỗi này VẪN bắt đầu bằng "https://myapp.com" nên check trên vẫn qua!

Cách đúng là so khớp tuyệt đối, toàn bộ chuỗi với danh sách URI đã đăng ký sẵn cho từng ứng dụng khách (client_id), thay vì đoán theo tiền tố hay domain:

const registeredRedirects = {
  client_123: [
    'https://myapp.com/oauth/callback',
    'https://myapp.com/mobile/callback',
  ],
};

function isValidRedirect(clientId, uri) {
  const allowed = registeredRedirects[clientId] || [];
  return allowed.includes(uri); // so khop chinh xac tung ky tu
}

Hãy hình dung redirect_uri như địa chỉ giao hàng. Một công ty vận chuyển đáng tin cậy không giao hàng theo địa chỉ khách gõ tùy ý trên đơn hàng, mà chỉ giao tới các địa chỉ đã đăng ký và xác minh trước trong hồ sơ khách hàng. Máy chủ ủy quyền cũng vậy: chỉ chuyển hướng (giao mã ủy quyền) tới những redirect_uri đã đăng ký sẵn cho đúng ứng dụng khách đó, không tin theo giá trị mà request gửi lên.

2. Tránh response_type=token, ưu tiên đổi lấy mã ủy quyền

response_type=token là cách trả access token trực tiếp ngay từ điểm cuối ủy quyền, không qua bước đổi mã. Cách này gọi là luồng cấp quyền ngầm định (implicit grant), từng được thiết kế riêng cho ứng dụng chạy hoàn toàn trên trình duyệt (không có phần server để giữ bí mật).

Vấn đề nằm ở chỗ access token được trả về nằm ngay trong phần fragment của URL, kiểu:

https://myapp.com/callback#access_token=eyJhbGciOiJIUzI1NiJ9...&token_type=Bearer&expires_in=3600

Token nằm lộ thiên trên URL nghĩa là nó có thể bị lưu vào lịch sử trình duyệt, rò rỉ qua header Referer khi trang gọi tài nguyên bên ngoài, lộ trong nhật ký proxy hoặc bị các tiện ích mở rộng (extension) độc hại đọc trộm. Với luồng cấp mã ủy quyền, thứ duy nhất chạy qua trình duyệt là mã dùng một lần; access token thật sự chỉ được trả về qua một cuộc gọi HTTP trực tiếp máy chủ tới máy chủ, không ai ở giữa nhìn thấy được:

https://myapp.com/callback?code=SplxlOBeZQQYbYS6WxSbIA&state=af0ifjsldkj

Ví von cho dễ nhớ: response_type=token giống như viết số thẻ ngân hàng ra mặt sau tấm bưu thiếp rồi gửi qua đường bưu điện thường, ai cầm được bưu thiếp cũng đọc được. Luồng cấp mã ủy quyền giống gửi một mã nhận hàng dùng một lần; muốn lấy được "tiền" (access token) thật, phải mang mã đó tới đúng quầy giao dịch (kênh server-to-server có xác thực bằng client_secret) mới đổi được.

Vì những rủi ro trên, khuyến nghị bảo mật mới nhất cho OAuth 2.0 (RFC 9700 - Best Current Practice for OAuth 2.0 Security) đã đi xa hơn: không chỉ tránh, mà khuyên bỏ hẳn luồng cấp quyền ngầm định. Kể cả ứng dụng một trang (SPA) chạy hoàn toàn phía client cũng nên dùng luồng cấp mã ủy quyền kết hợp PKCE - Proof Key for Code Exchange (RFC 7636): một cơ chế cho phép ứng dụng không giữ được bí mật (không có client_secret an toàn) vẫn chứng minh được chính nó là bên đã khởi tạo yêu cầu, mà không cần lộ token qua URL.

3. Dùng tham số state để ngăn tấn công CSRF

Tham số state là một giá trị ngẫu nhiên do ứng dụng khách tự sinh ra trước khi chuyển hướng người dùng sang máy chủ ủy quyền. Giá trị này đi kèm theo suốt yêu cầu, và máy chủ ủy quyền có nhiệm vụ gửi nguyên vẹn lại khi chuyển hướng trình duyệt quay về.

Nếu bỏ qua bước này, kẻ tấn công có thể tự khởi tạo một luồng OAuth bằng chính tài khoản của hắn, lấy được mã ủy quyền hợp lệ, rồi dụ nạn nhân mở đường link callback đó. Nếu ứng dụng của bạn không kiểm tra state, nó sẽ hồn nhiên gắn tài khoản của kẻ tấn công vào phiên đăng nhập của nạn nhân, đây chính là dạng tấn công giả mạo yêu cầu liên trang (CSRF) áp dụng riêng cho OAuth, đôi khi còn gọi là "authorization code injection".

const crypto = require('crypto');

// Buoc 1: truoc khi chuyen huong user sang authorization server
app.get('/login', (req, res) => {
  const state = crypto.randomBytes(16).toString('hex');
  req.session.oauthState = state; // gan voi phien cua dung nguoi dung nay

  const params = new URLSearchParams({
    response_type: 'code',
    client_id: 'client_123',
    redirect_uri: 'https://myapp.com/oauth/callback',
    scope: 'read:profile',
    state,
  });
  res.redirect(`https://auth.example.com/authorize?${params}`);
});

// Buoc 2: khi authorization server chuyen huong quay lai
app.get('/oauth/callback', (req, res) => {
  const { code, state } = req.query;

  if (!state || state !== req.session.oauthState) {
    return res.status(403).send('state khong khop, tu choi yeu cau');
  }
  delete req.session.oauthState; // dung mot lan roi bo, khong tai su dung

  // ... tiep tuc doi code lay access token qua kenh server-to-server
});

Bạn có thể hình dung state như tấm vé giữ đồ ở quầy gửi áo khoác. Khi gửi áo, bạn nhận một tấm vé mang số ngẫu nhiên. Lúc lấy lại, nhân viên chỉ trả áo cho ai đưa đúng số vé đó, chứ không trả cho bất kỳ ai bước tới quầy. Máy chủ của bạn cũng phải làm y hệt: chỉ chấp nhận callback nếu state trả về khớp với state đã phát ra cho đúng phiên đó.

Lưu ý: state phải được sinh ngẫu nhiên đủ mạnh về mặt mật mã (dùng crypto.randomBytes, không dùng Math.random() hay số đếm tăng dần), gắn chặt với phiên của từng người dùng, và chỉ dùng được đúng một lần. Nếu để state đoán được hoặc tái sử dụng, biện pháp này gần như vô tác dụng.

4. Đặt phạm vi mặc định và xác thực phạm vi cho từng ứng dụng

Phạm vi (scope) dùng để chỉ định chính xác quyền và mức truy cập mà một ứng dụng khách được cấp khi thay mặt người dùng gọi tới tài nguyên được bảo vệ, ví dụ read:profile, read:email, write:posts.

Đặt sẵn một phạm vi mặc định (tập quyền tối thiểu áp dụng chung khi không có yêu cầu cụ thể) giúp mọi ứng dụng tuân theo cùng một mức kiểm soát cơ bản. Nhưng chỉ có mặc định thôi chưa đủ: máy chủ còn phải xác thực rằng phạm vi mà một ứng dụng khách yêu cầu có thật sự nằm trong danh sách được phép của riêng ứng dụng đó hay không. Thiếu bước này, một ứng dụng vốn chỉ nên đọc hồ sơ công khai vẫn có thể xin thêm quyền ghi dữ liệu hay quyền quản trị, và nếu máy chủ không chặn, người dùng vô tình cấp quyền vượt xa những gì ứng dụng thật sự cần.

const clientAllowedScopes = {
  client_123: ['read:profile', 'read:email'],
  client_456: ['read:profile', 'write:posts', 'admin:users'],
};

function validateScope(clientId, requestedScope) {
  const requested = requestedScope.split(' ');
  const allowed = clientAllowedScopes[clientId] || [];
  const invalid = requested.filter((s) => !allowed.includes(s));

  if (invalid.length > 0) {
    throw new Error(`Client khong duoc cap scope: ${invalid.join(', ')}`);
  }
  return requested;
}

Ví von: scope giống như chìa khóa valet mà bãi đỗ xe khách sạn đưa cho nhân viên trông xe. Chìa khóa này chỉ khởi động và lái xe được trong khuôn viên bãi đỗ, không mở được cốp xe hay ngăn đựng đồ. Bạn không đưa chìa khóa chính (toàn quyền) cho một người chỉ cần đỗ xe giúp bạn. Scope trong OAuth cũng vậy: cấp đúng và đủ quyền cho từng ứng dụng, không hơn.

Vài cạm bẫy khác nên nhớ khi triển khai OAuth:
  • redirect_uri nên bắt buộc HTTPS (trừ khi test trên localhost khi phát triển).
  • Mã ủy quyền (authorization code) phải sống ngắn (thường dưới 1 phút) và chỉ dùng được một lần; dùng lại lần hai phải bị từ chối và nên thu hồi luôn access token đã cấp trước đó.
  • Với ứng dụng di động hoặc SPA (không giữ được client_secret an toàn), hãy dùng PKCE thay vì tin vào việc giấu bí mật trong mã nguồn client, vì mã nguồn phía client luôn có thể bị đọc ngược.
  • Không ghi log access token hay authorization code dưới dạng chữ thường (plaintext); nếu cần log để debug, hãy che bớt (mask) phần lớn chuỗi.

Tóm tắt

  • So khớp redirect_uri tuyệt đối theo danh sách đã đăng ký cho từng client, không dùng startsWith hay so khớp domain lỏng lẻo.
  • Bỏ luồng cấp quyền ngầm định (response_type=token); dùng luồng cấp mã ủy quyền, và thêm PKCE nếu ứng dụng không giữ được bí mật phía server.
  • Luôn sinh và xác thực state ngẫu nhiên, gắn với phiên người dùng, dùng một lần, để chặn CSRF trên luồng OAuth.
  • Đặt phạm vi mặc định tối thiểu và xác thực phạm vi yêu cầu theo đúng danh sách được phép của từng ứng dụng khách.

Nguồn tham khảo

- Kai

Thấy bài viết hữu ích?

0 lượt thích

Đăng nhận xét