# 1. Cookie ## 1.1. Giới thiệu `Cookie` là một file nhỏ mà server gửi đến client và được lưu trữ trên máy client. Cookie được sử dụng để lưu trữ thông tin của client, thông tin này sẽ được gửi lại server mỗi khi client gửi request đến server. Cookie được sử dụng để xác thực, theo dõi và lưu trữ thông tin của người dùng. Thông thường, mỗi một `request` gửi lên `NodeJS` theo phương thức `HTTP`. Mà `HTTP` là `stateless protocol`, nghĩa là mỗi request là một request mới, không có liên quan gì với nhau > Ví dụ: Khi người dùng login vào hệ thống, lưu biến `req.isLogin = true`, khi người dùng request trang khác thì lúc đó `req.isLogin` sẽ không còn nữa do `HTTP` là `stateless protocol`. Muốn lưu giữ giá trị này mỗi lần `request` thì ta phải lưu vào `middleware` đặt trước các route, `middleware` sẽ chạy trước và thực hiện gán giá trị cho `req.isLogin` trước khi `route` được thực thi. > Nhưng nếu lưu vào `middleware` thì mỗi lần `request` sẽ là một lần phải thực hiện lại, rất tốn tài nguyên. Do đó để giải quyết vấn đề này, ta sử dụng `cookies` để lưu trữ thông tin người dùng ở phía client. ## 1.2. Cách hoạt động Khi server gửi một `response` chứa `cookie` đến client, `cookie` sẽ được lưu trữ trên máy client. Mỗi lần client gửi `request` đến server, `cookie` sẽ được gửi kèm theo `request`. Server sẽ đọc `cookie` và sử dụng thông tin trong `cookie` để xác thực và theo dõi người dùng. ## 1.3. Cấu trúc của cookie `Cookie` bao gồm các thành phần sau: - `Name`: Tên của `cookie`. - `Value`: Giá trị của `cookie`. - `Domain`: Tên miền mà `cookie` áp dụng. - `Path`: Đường dẫn mà `cookie` áp dụng. - `Expires`: Thời gian hết hạn của `cookie`. - `Size`: Kích thước của `cookie`. - `HttpOnly`: `Cookie` chỉ có thể được truy cập thông qua `HTTP`. - `Secure`: `Cookie` chỉ được gửi qua kết nối `HTTPS`. ## 1.4. Sử dụng cookie trong NodeJS Chúng ta có 2 cách để sử dụng `cookie` trong `NodeJS`. Một là sử dụng `express` + `cookie-parser` và hai là sử dụng cách thủ công. ### 1.4.1. Sử dụng `express` + `cookie-parser` Để sử dụng `cookie` trong `NodeJS`, chúng ta cần cài đặt thư viện `cookie-parser` bằng cách chạy lệnh sau: ```bash $ npm install cookie-parser ``` Sau đó, chúng ta sử dụng `cookie-parser` trong `NodeJS` như sau: 1. Khai báo, sử dụng `cookie-parser` trong `app.js`: > File `app.js` ```javascript const express = require('express'); const cookieParser = require('cookie-parser'); // Import thư viện cookie-parser const app = express(); app.use(cookieParser("secret")); // Sử dụng cookie-parser với secret key là "secret" dùng để mã hóa cookie ``` 2. Sử dụng các `hàm` sau để làm việc với `cookie` khi trả về dữ liệu cho `client`: - `res.cookie(name, value, {options})`: Tạo một `cookie` với `name`, `value` và `options`. - `res.clearCookie(name)`: Xóa `cookie` với `name` đã cho. - `req.cookies.`: Đọc `cookie` với `name` đã cho từ phía `sever` khi `client` gửi `request`. - `req.signedCookies.`: Lấy giá trị của cookies đã được mã hóa - `res.cookie("cookieName", "cookieValue", {signed: true})`: Mã hóa cookies với secret key đã khai báo ở trên - `res.cookie("cookieName", "cookieValue", {maxAge: 1000})`: Set thời gian tồn tại của cookies (1s) - `res.cookie("cookieName", "cookieValue", {httpOnly: true})`: Set cookies chỉ có thể được truy cập bởi chính server - `res.cookie("cookieName", "cookieValue", {secure: true})`: Cookies chỉ có thể được truy cập bởi https - `res.cookie("cookieName", "cookieValue", {sameSite: true})`: Cookies chỉ có thể được truy cập bởi cùng một domain - `res.cookie("cookieName", "cookieValue", {path: "/login"})`: Cookies chỉ có thể được truy cập bởi đường dẫn `"/login"` - `res.cookie("cookieName", "cookieValue", {domain: "localhost"})`: Cookies chỉ có thể được truy cập bởi domain "localhost" - `res.cookie("cookieName", "cookieValue", {expires: new Date(Date.now() + 1000)})`: Dùng để set thời gian hết hạn của cookies ### 1.4.2. Sử dụng cách thủ công Chúng ta cũng có thể sử dụng `cookie` mà không cần sử dụng `cookie-parser`. Để làm điều này, chỉ cần sử dụng `header` của `response` và `request` để gửi và nhận `cookie`. - `res.setHeader("Set-Cookie", "cookieName=cookieValue; HttpOnly")`: Set `cookie` với `name` là `cookieName` và `value` là `cookieValue` với `HttpOnly` là chỉ có thể được truy cập thông qua `HTTP`. - `req.headers.cookie`: để lấy giá trị của cookies từ `request` gửi lên server từ phía client. - `res.setHeader("Set-Cookie", "cookieName=cookieValue; Max-Age=1000")`: Set cookies với name là `cookieName`, value là `cookieValue` và thời gian tồn tại của cookies là `1s`. - `res.setHeader("Set-Cookie", "cookieName=cookieValue; Secure")`: Set cookies chỉ có thể được truy cập bởi https - `res.setHeader("Set-Cookie", "cookieName=cookieValue; SameSite=Strict")`: Set cookies chỉ có thể được truy cập bởi cùng một domain - `res.setHeader("Set-Cookie", "cookieName=cookieValue; Path=/login")`: Set cookies chỉ có thể được truy cập bởi đường dẫn "*/login" - `res.setHeader("Set-Cookie", "cookieName=cookieValue; Domain=localhost")`: Set cookies chỉ có thể được truy cập bởi domain "localhost" - `res.setHeader("Set-Cookie", "cookieName=cookieValue; Expires=Thu, 01 Jan 1970 00:00:00 GMT")`: Để set thời gian hết hạn của cookies > LƯU Ý: Khi dùng cookie sẽ dễ bị sửa giá trị của cookie, bị hack khi mở dev tool, nên dùng session để lưu trữ thông tin người dùng # 2. Session ## 2.1. Giới thiệu `Session` là một cách để lưu trữ thông tin của người dùng trên server. Mỗi khi người dùng truy cập vào hệ thống, server sẽ tạo một `session` mới và gán một `session id` cho `session` đó. `Session id` sẽ được gửi đến client và lưu trữ trong `cookie`. Mỗi khi client gửi `request` đến server, `session id` sẽ được gửi kèm theo `request`. Server sẽ đọc `session id` và sử dụng `session id` để lấy thông tin của `session` từ `server`. Nó được phân biệt với các phiên khác bởi người truy cập, trình duyệt và thời gian... nên có nhiều phiên có thể được mở cùng một lúc ## 2.2. Cách hoạt động Chúng ta nên có một `database` ở phía `server` để lưu trữ thông tin của `session`. Mỗi lần người dùng truy cập vào hệ thống, server sẽ tạo một `session` mới và lưu trữ thông tin của `session` vào `database`. `Session id` sẽ được gửi đến client và lưu trữ trong `cookie`. Mỗi khi client gửi `request` đến server, `session id` sẽ được gửi kèm theo `request`. Server sẽ đọc `session id` và sử dụng `session id` để lấy thông tin của `session` từ `database`. ## 2.3. Cách sử dụng session trong NodeJS (Kết hợp với Cookie + `MongoDB` làm database lưu trữ session) Chúng ta cần các package sau để sử dụng `session` trong `NodeJS`: - `express-session`: Để sử dụng `session` trong `NodeJS`. - `connect-mongodb-session`: Để lưu trữ `session` vào `MongoDB`. Để cài đặt các package trên, chúng ta chạy lệnh sau: ```bash $ npm install express-session connect-mongodb-session ``` Sau đó, chúng ta sử dụng `express-session` và `connect-mongodb-session` như sau: 1. Khởi tạo `collections db` của mongodb để lưu trữ `session`, sau đó cấu hình `session` trong `app.js`: > File `app.js` ```javascript const express = require('express'); const app = express(); const session = require('express-session'); // Import thư viện express-session const MongoDBStore = require('connect-mongodb-session')(session); // Import thư viện connect-mongodb-session và truyền vào thư viện express-session // Tạo store để lưu trữ session vào database const store = new MongoDBStore({ uri: 'mongodb://localhost:27017/your-database-name', // Đường dẫn đến database (URI của MongoDB database) collection: 'sessions' // Tên của collection để lưu trữ session }); // Cấu hình session app.use( session({ secret: "Nguyen Di Dan", // Chuỗi bí mật để mã hoá session resave: false, // resave: false => Không lưu lại session nếu không có sự thay đổi (Không cần thiết) saveUninitialized: false, // saveUninitialized: false => Không lưu lại session nếu không có sự thay đổi (Không cần thiết) // resave vs saveUninitialized: https://stackoverflow.com/questions/40381401/when-use-saveuninitialized-and-resave-in-express-session store: store, // Lưu session vào database (store đã tạo ở trên) // Ngoài ra có thể tuỳ chỉnh thêm cho cookie: secure, path, signed,... ở cấu hình session cookie: { signed: true, // Mã hóa cookie với secret key đã khai báo ở trên }, }) ); ``` 2. Sử dụng các `phương thức` sau để làm việc với `session`: - `req.session. = "sessionValue"`: Để set session với `name` là `sessionName` và `value` là `sessionValue`. - `req.session.destroy(callback)`: để xóa session, callback sẽ được gọi khi session đã được xóa. - `req.session.save(callback)`: để lưu session, callback sẽ được gọi khi session đã được lưu. (Lưu ý, trước khi sủe dụng `session.save()` thì phải set `session` trước đó). - `req.session.`: Để lấy giá trị của session từ server khi client gửi request lên. ## 2.4. Ví dụ về sử dụng session trong NodeJS (Xác định danh tính người dùng) Sau khi thực hiện các bước cấu hình `session` như trên, chúng ta sẽ thực hiện một ví dụ về xác định danh tính người dùng bằng `session` như sau: 1. Trong `app.js`, tạo 1 `middleware` để kiểm tra trong `session` có `user` hay không (Lưu ý, nên đặt `middleware` này trước các `route` để mỗi lần `request` đến server, `middleware` sẽ chạy trước và thực hiện kiểm tra `session`): > File `app.js` ```javascript // ... Cấu hình session như trên (Cấu hình session trong app.js) // {MIDDLEWARE PHÂN QUYỀN DÙNG SESSION} // app.use((req, res, next) => { if (!req.session?.user) { // Nếu không có session user thì return next() để chạy các middleware tiếp theo mà không có phân quyền return next(); } User.findById(req.session.user._id) // Tìm kiếm user trong collection users có id trùng với id của session user .then((user) => { // Nếu tìm thấy user thì lưu vào req.user if (user) { req.user = new User(user); // Lưu lại user vào request để sử dụng ở các middleware tiếp theo (không cần dùng new User vì user đã là object rồi, có thể dùng các method của mongoose cũng như từ class User luôn ) // Tuy nhiên, Ko cần req.user nữa vì dùng session rồi (biến user sẽ lưu vào req.session.user) next(); // Tiếp tục chạy các middleware tiếp theo với phân quyền } }) .catch((err) => console.log(err)); }); ``` 2. Tạo `route` để xử lý `login` và `logout` và `getAuth`: > File `route.js` ```javascript const express = require("express"); const route = express.Router(); const getAuth = require("../controllers/auth"); route.get("/login", getAuth.getAuth); route.post("/login", getAuth.postAuth); route.post("/logout", getAuth.postLogout) module.exports = route; ``` 3. Tạo `controller` để xử lý `login` và `logout` và `getAuth`: > File `auth.js` ```javascript const User = require("../models/users"); // {SESSION + COOKIES} // Đối với Session, phải tạo Session trước khi tạo Cookie const getAuth = (req, res, next) => { let isLogin = req.session.isLogin; // Lấy giá trị Session có tên là "isLogin" res.render("./auth/login", { title: "Login", path: "/login", authenticate: isLogin, }); }; const postAuth = (req, res, next) => { User.findById("64cc7af71adf0619fa3e8481") // Tìm kiếm 1 user trong collection có id là "64cc7af71adf0619fa3e8481" .then((user) => { req.session.isLogin = true; // Tạo Session có tên là "isLogin", giá trị là "true" req.session.user = user; // Tạo Session có tên là "user", giá trị là user vừa tìm được // req.session.cookie.maxAge = 3000; // Thời gian tồn tại của Session là 3s req.session.save(() => { // Lưu lại Session res.redirect("/"); // Sau khi lưu lại Session thì mới chuyển hướng sang trang chủ (vì lưu lại Session là bất đồng bộ) }); }) .catch((err) => console.log(err)); }; // LOGOUT => SESSION SẼ XOÁ const postLogout = (req, res, next) => { req.session.destroy(() => { // Xoá Session res.redirect("/"); // Sau khi xoá Session thì mới chuyển hướng sang trang chủ (vì xoá Session là bất đồng bộ) }); }; module.exports = { getAuth, postAuth, postLogout, }; ``` # 3. Authentication ## 3.1. Giới thiệu Trong phần này, sẽ nói về: - Đăng ký, đămg nhập, xác thực người dùng, sử dụng `session` và `cookie`. - Phân quyền người dùng - Tìm hiểu về `middleware`. Ẩn và bảo vệ các `route` không cho người dùng không có quyền truy cập. - Tạo biến `locals` để sử dụng ở bất cứ đâu trong `view`. - Sử dụng `connect-flash` để hiển thị thông báo cho người dùng trong `view`. - Tìm hiểu về `csrf` và cách bảo vệ trước `csrf`. - Sử dụng `JWT` để xác thực người dùng (Thay thế cho `session`, `cookie` và `csrf`). ## 3.2. Mã hóa mật khẩu Khi lưu trữ mật khẩu người dùng vào `database`, chúng ta cần mã hóa mật khẩu để bảo mật thông tin người dùng. Để mã hóa mật khẩu, chúng ta sử dụng `bcryptjs` để mã hóa mật khẩu. ### 3.2.1. Cài đặt `bcryptjs` Để cài đặt `bcryptjs`, chúng ta chạy lệnh sau: ```bash $ npm install bcryptjs ``` ### 3.2.2. Sử dụng `bcryptjs` Chúng ta sử dụng `bcryptjs` như sau: 1. Import `bcryptjs` vào file `model`: > File `user.js` ```javascript const bcrypt = require("bcryptjs"); const { Schema, model } = require("mongoose"); // Schema của user const userSchema = new Schema({ email: { type: String, required: true, }, password: { type: String, required: true, }, }); // Mã hóa mật khẩu trước khi tạo mới một user và lưu vào database bằng hàm `save` của mongoosem bằng cách sử dụng `pre` hook userSchema.pre("save", function (next) { bcrypt.hash(this.password, 12, (err, hash) => { // Mã hóa mật khẩu với số lần mã hóa là 12 if (err) { return next(err); } this.password = hash; next(); // Tiếp tục chạy middleware tiếp theo }); }); module.exports = model("User", userSchema); ``` 2. Tạo `user` mới và lưu vào `database`: > File `auth.js` ```javascript const User = require("../models/users"); const postAuth = (req, res, next) => { const { email, password } = req.body; User.findOne({ email: email }) // Tìm kiếm user trong collection users có email trùng với email người dùng nhập vào .then((user) => { if (!user) { // Nếu không tìm thấy user thì trả về lỗi return res.redirect("/login"); } // So sánh mật khẩu người dùng nhập vào với mật khẩu đã mã hóa trong database bcrypt.compare(password, user.password, (err, result) => { if (err) { return res.redirect("/login"); // nếu so sánh mật khẩu lỗi thì redirect về trang login (view engine) } if (result) { req.session.isLogin = true; // Tạo Session có tên là "isLogin", giá trị là "true" (Sesion đã tạo ở phần #2.3) req.session.user = user; req.session.save(() => { res.redirect("/"); }); // Lưu lại Session } else { res.redirect("/login"); } }); }) .catch((err) => console.log(err)); }; ``` > Chúng ta có thể thấy, chúng ta sử dụng `bcrypt.compare()` để so sánh mật khẩu người dùng nhập vào với mật khẩu đã mã hóa trong `database`. `bcrypt.hash()` dùng để mã hóa mật khẩu. > `Mongoose` cung cấp các `hook` như `pre`, `post` để thực hiện các hành động trước hoặc sau khi thực hiện các hành động như `save`, `update`, `delete`... ## 3.3. Phân quyền người dùng ### 3.3.1. Phân quyền người dùng Khi xây dựng một ứng dụng, chúng ta cần phân quyền người dùng để bảo vệ thông tin và dữ liệu của người dùng. Chúng ta có thể phân quyền người dùng bằng cách sử dụng `middleware` để kiểm tra quyền truy cập của người dùng. `Middleware` là một hàm có thể truy cập vào `request`, `response` và `next` của `Express`. `Middleware` có thể thực hiện các hành động như kiểm tra quyền truy cập, xác thực người dùng, xử lý dữ liệu trước khi gửi về `client`. Nó được đặt trước `route` và được thực thi mỗi khi `request` đến server. `Middleware` tương tự như `Controller` có 3 thành phần chính: - `Request` (`req`): Đại diện cho `request` gửi đến server. Nó bao gồm các thuộc tín có thể truy cập như: + `req.body`: Dữ liệu gửi lên server từ phía client. + `req.params`: Các tham số truyền vào từ `url`. + `req.query`: Các tham số truyền vào từ `query string`. + `req.cookies`: Các `cookie` gửi kèm theo `request`. + `req.session`: Các `session` gửi kèm theo `request`. + `req.headers`: Các `header` gửi kèm theo `request`. - `Response` (`res`): Đại diện cho `response` trả về từ server. Nó bao gồm các phương thức để trả về dữ liệu cho client như: + `res.send()`: Trả về dữ liệu cho client. + `res.json()`: Trả về dữ liệu dạng `json` cho client. + `res.render()`: Trả về `view` cho client. + `res.redirect()`: Chuyển hướng client đến một `url` khác. + `res.cookie()`: Trả về `cookie` cho client. + `res.session()`: Trả về `session` cho client. - `Next` (`next`): Đại diện cho hàm tiếp theo trong chuỗi `middleware`. Nó được sử dụng để chuyển hướng `request` sang `middleware` tiếp theo bằng cách gọi hàm `next()`. ### 3.3.2. Sử dụng `middleware` để phân quyền người dùng Chúng ta sử dụng `middleware` để phân quyền người dùng như sau: 1. Tạo `middleware` để kiểm tra quyền truy cập của người dùng: > File `auth.js` ```javascript const checkAuth = (req, res, next) => { if (!req.session.isLogin) { // Do khi login thành công thì chúng ta đã tạo session isLogin = true, nên nếu không có session này thì chưa login return res.redirect("/login"); // Nếu không có session isLogin thì redirect về trang login } next(); }; //... ``` 2. Sử dụng `middleware` trong `route`: > File `route.js` ```javascript const express = require("express"); const route = express.Router(); const getAuth = require("../controllers/auth"); const checkAuth = require("../middleware/auth"); route.get("/login", getAuth.getAuth); route.post("/login", getAuth.postAuth); route.post("/logout", getAuth.postLogout); route.get("/", checkAuth, getAuth.getIndex); // Sử dụng middleware checkAuth ở đây để kiểm tra quyền truy cập của người dùng, nó sẽ chạy trước khi route được thực thi, nếu ok thì tiếp tục thực thi hàm sau đó module.exports = route; ``` ## 3.4. Tạo biến `locals` để sử dụng ở bất cứ đâu trong `view` Khi xây dựng một ứng dụng, chúng ta cần truyền dữ liệu từ `controller` sang `view` để hiển thị dữ liệu cho người dùng. Tuy nhiên, không phải lúc nào chúng ta cũng cần truyền dữ liệu từ `controller` sang `view`. Để giải quyết vấn đề này, chúng ta sử dụng `locals` để truyền dữ liệu từ `controller` sang `view` mà không cần truyền qua `res.render()` mà tất cả các `view` đều có thể truy cập được. ### 3.4.1. Sử dụng `locals` Chúng ta sử dụng `locals` như sau: 1. Tạo biến `locals` trong `app.js`: > File `app.js` ```javascript app.use((req, res, next) => { res.locals.isAuthenticated = req.session.isLogin; // Tạo biến isAuthenticated trong locals để kiểm tra người dùng đã đăng nhập hay chưa next(); }); ``` 2. Sử dụng biến `locals` trong `view`: > File `index.ejs` ```html ``` > Chúng ta có thể thấy, chúng ta sử dụng biến `isAuthenticated` trong `view` để kiểm tra người dùng đã đăng nhập hay chưa. ## 3.5. Sử dụng `connect-flash` để hiển thị thông báo cho người dùng trong `view` Khi xây dựng một ứng dụng, chúng ta cần hiển thị thông báo cho người dùng khi thực hiện các hành động như `login`, `logout`, `đăng ký`, `thêm`, `sửa`, `xóa` dữ liệu. Để hiển thị thông báo cho người dùng, chúng ta sử dụng `connect-flash`. Để sử dụng `connect-flash`, chúng ta cần sử dụng và thiết lập `session` ### 3.5.1. Cài đặt `connect-flash` Để cài đặt `connect-flash`, chúng ta chạy lệnh sau: ```bash $ npm install connect-flash ``` ### 3.5.2. Sử dụng `connect-flash`. Chúng ta sử dụng biến `request` để lưu trữ thông báo và hiển thị thông báo cho người dùng. `connect-flash` có các cách sử dụng như sau: `req.flash("", "")`. Đê lấy ra `message` từ `flash`, chúng ta sử dụng `req.flash("")`. `connect-flash` sẽ trả về một `mảng` chứa các `message` có tên `flash` đã cho. > Các thông báo này được lưu vào 1 `mảng` trong session, sau khi hiển thị thì nó sẽ `tự động bị xóa` khỏi session ngay lập tức => `(chỉ hiển thị 1 lần duy nhất)` sau đó reload lại trang thì sẽ không còn thông báo nữa ### 3.5.3. Ví dụ sử dụng `connect-flash` như sau: 1. Import `connect-flash` vào file `app.js`: > File `app.js` ```javascript const express = require("express"); const app = express(); const flash = require("connect-flash"); app.use(flash()); ``` 2. Sử dụng `connect-flash` trong `controller`: > File `controller.js` ```javascript const postAuth = (req, res, next) => { const email = req.body.email; // Lấy giá trị email từ form const password = req.body.password; // Lấy giá trị password từ form User.findOne({ email: email }) // Tìm user có email = email .then((user) => { if (!user) { // Nếu không tìm thấy user // {FLASH MESSAGE} // Nếu password không trùng khớp req.flash("errorLogin", "Email or Password does not match!"); // Tạo flash message có tên là "error", giá trị là "Email or Password does not match!" return res.redirect("/login"); // Chuyển hướng về trang login } bcrypt .compare(password, user.password) // So sánh password nhập vào với password đã mã hoá trong database .then((isMatch) => { if (isMatch) { // {FLASH MESSAGE} // req.flash("successLogin", "Login successfully!"); // Tạo flash message có tên là "success", giá trị là "Login successfully!" // Nếu password trùng khớp req.session.isLogin = true; // Tạo Session có tên là "isLogin", giá trị là "true" req.session.user = user; // Tạo Session có tên là "user", giá trị là user vừa tìm được // req.session.cookie.maxAge = 3000; // Thời gian tồn tại của Session là 3s return req.session.save(() => { // Lưu Session res.redirect("/"); // Sau khi lưu Session thì mới chuyển hướng sang trang chủ (vì lưu Session là bất đồng bộ) }); } else { // {FLASH MESSAGE} // Nếu password không trùng khớp req.flash("errorLogin", "Email or Password does not match!"); // Tạo flash message có tên là "error", giá trị là "Email or Password does not match!" return res.redirect("/login"); // Chuyển hướng về trang login } }) .catch((err) => console.log(err)); }) .catch((err) => console.log(err)); }; const getAuth = (req, res, next) => { const [errorMessage] = req.flash("errorLogin"); // Lấy giá trị flash message có tên là "error" const [successSignup] = req.flash("successSignup"); // Lấy giá trị flash message có tên là "successSigup" res.render("./auth/login", { title: "Login", path: "/login", successSignup: successSignup, // Truyền giá trị flash message có tên là "success" vào biến successSigup errorMessage: errorMessage, // Truyền giá trị flash message có tên là "error" vào biến errorMessage }); }; ``` 3. Sử dụng `connect-flash` trong `view`: > File `login.ejs` ```html

<% if (errorMessage) { %>

<%= errorMessage %>

<% } %> <% if (successSignup) { %>

<%= successSignup %>

<% } %>

``` ### 3.6.2. Sử dụng `csrf` để bảo vệ trước `CSRF` Chúng ta sử dụng package `csrf` để bảo vệ trước `CSRF`. Để cài đặt `csurf`, chúng ta chạy lệnh sau: ```bash $ npm install csrf ``` Với các hàm xác minh `CSRF` token, chúng ta sử dụng `middleware` và đặt `middleware` trước các `route` cần bảo vệ trước `CSRF`. Với `View Engine`, chúng ta sử dụng `csurf` bằng cách thêm `csrf token` vào `view` và gửi `csrf token` kèm theo `request` từ `client`. VD như trong form khi gửi lên ta kèm theo đoạn sau `` (Với `name` bắt buộc phải là `_csrf`) ### 3.6.3. Ví dụ sử dụng `csurf` như sau: 1. Import `csurf` vào file `app.js`: > File `app.js` ```javascript const express = require("express"); const app = express(); // {CSRF khai báo sau khi định nghĩa SESSION} // const Tokens = require("csrf"); // Nhập module csrf const csrf = new Tokens(); // Tạo 1 object csrf let csrfToken // {MIDDLEWARE ĐỂ TRUYỀN BIẾN LOCALS CHO TẤT CẢ CÁC ROUTE} // const CreateCSRFTOKEN = (req, res, next) => { csrfToken = csrf.create("nguyendidan"); // Tạo 1 token với secret key res.locals.authenticate = req.session.isLogin; // Truyền biến authenticate vào locals để sử dụng ở tất cả các route res.locals.csrfToken = csrfToken; // Truyền biến csrfToken vào locals để sử dụng ở tất cả các route next(); }; // Sử dụng middleware bảo vệ các route, nếu không có token thì các lệnh request sẽ báo lỗi app.use(csrf()); // Tạo middleware csurf vào app ``` 2. Sử dụng `csrf` trong `view`: > File `login.ejs` ```html ``` 3. Tạo middleware để xác minh `csrf Token` mà client gửi lên, rồi đặt middleware này trước mỗi request của route. > File `middleware.js` ```javascript import { Tokens } from "csrf"; const csrf = new Tokens(); const verifyCSRFToken = (req, res, next) => { const token = req.body._csrf || req.get('X-CSRF-Token'); // Lấy token từ form, nếu dùng API thì lấy từ header X-CSRF-Token if (!csrf.verify("nguyendidan", token)) { // Nếu token không trùng với token được tạo ra từ secret const err = new Error("Invalid CSRF Token"); // Tạo 1 error err.httpStatusCode = 403; // Gán httpStatusCode cho error return next(err); // Trả về error } next(); }; ``` ## 3.7. Sử dụng `JWT` để xác thực người dùng (Thay thế cho `session`, `cookie` và `csrf`) ### 3.7.1. Giới thiệu `JWT` (JSON Web Token) là một chuẩn mở để tạo ra một cách an toàn để truyền thông tin giữa các bên dưới dạng một đối tượng JSON. `JWT` được mã hóa và ký số để đảm bảo tính toàn vẹn của dữ liệu. `JWT` hoạt động như sau: 1. Khi người dùng truy cập vào trang web, server sẽ tạo một `JWT` và gửi về cho `client`. 2. `Client` sẽ lưu trữ `JWT` vào `cookie` hoặc `local storage`. 3. Khi người dùng thực hiện một hành động như `login`, `đăng ký`, `thêm`, `sửa`, `xóa` dữ liệu, `client` sẽ gửi `JWT` kèm theo `request`. 4. Server sẽ kiểm tra `JWT` từ `request` có trùng với `JWT` đã gửi về từ `client` hay không. Nếu trùng khớp, server sẽ thực hiện hành động, ngược lại, server sẽ từ chối `request`. ### 3.7.2. Cấu trúc của `JWT` `JWT` có 3 phần chính: - `Header`: Chứa thông tin về loại `token` và thuật toán mã hóa. - `Payload`: Chứa thông tin về người dùng. - `Signature`: Chứa chữ ký số để đảm bảo tính toàn vẹn của `JWT`. ### 3.7.3. Sử dụng `JWT` để xác thực người dùng Chúng ta sử dụng `jsonwebtoken` để tạo và xác thực `JWT`. Để cài đặt `jsonwebtoken`, chúng ta chạy lệnh sau: ```bash $ npm install jsonwebtoken ``` Package `jsonwebtoken` cung cấp các phương thức để tạo và xác thực `JWT` như sau: - `jwt.sign(payload, secretOrPrivateKey, {options})`: Để tạo `JWT token` với `payload` là dữ liệu cần mã hóa, `secretOrPrivateKey` là chuỗi bí mật để mã hóa `JWT`. Các `options` bao gồm: + `expiresIn`: Thời gian tồn tại của `JWT`. VD: `1h`, `1d`, `1w`, `1m`, `1y`. + `algorithm`: Thuật toán mã hóa `JWT`. VD: `HS256`, `HS384`, `HS512`. - `jwt.verify(token, secretOrPublicKey, {options})`: Để xác thực `JWT token` với `token` là `JWT token` cần xác thực, `secretOrPublicKey` là chuỗi bí mật để xác thực `JWT`. Các `options` bao gồm: + `algorithm`: Thuật toán mã hóa `JWT`. VD: `HS256`, `HS384`, `HS512`. - `jwt.decode(token)`: Để giải mã `JWT token` và trả về `payload`. Sau khi xác thực `credentials` thành công, chúng ta sẽ tạo `JWT token` và gửi về cho `client`. `Client` sẽ lưu trữ `JWT token`. Mỗi lần `client` gửi `request` đến server, `client` sẽ gửi `JWT token` kèm theo `request` ở trong `header` của `request` với `key` là `Authorization` và `value` là `Bearer `. 1. Import `jsonwebtoken` vào file `auth.js`: > File `auth.js` ```javascript const jwt = require("jsonwebtoken"); const postAuth = (req, res, next) => { // Sau khi xác thực người dùng thành công const accessToken = jwt.sign({ email: email }, "Nguyen Di Dan", { expiresIn: "1h" }); // Tạo JWT token với payload là email, secret là "Nguyen Di Dan", thời gian tồn tại là 1h const refreshToken = jwt.sign({ email: email }, "Nguyen Di Dan", { expiresIn: "7d" }); // Tạo JWT token với payload là email, secret là "Nguyen Di Dan", thời gian tồn tại là 7d // Dùng session, hoặc database, để lưu accessToken và refreshToken req.session.accessToken = accessToken; // Lưu accessToken vào session req.session.refreshToken = refreshToken; // Lưu refreshToken vào session // Lưu session và Trả về JWT token cho client req.session.save(() => { res.status(200).json({ accessToken: accessToken, refreshToken: refreshToken, }); }); } ``` 2. Sử dụng `middleware` để xác thực `JWT` hoặc tạo một `access token` mới nếu `access token` hết hạn: > File `auth.js` ```javascript const jwt = require("jsonwebtoken"); // Import thư viện jsonwebtoken const genJWT = require("./jwtGeneration"); const invalidToken = []; // Mảng chứa các token không hợp lệ (đã hết hạn hoặc không hợp lệ) const ProtectRoute = async (req, res, next) => { try { const header = req.header("Authorization"); // Lấy header Authorization (Bearer token) const accessToken = header && header.split(" ")[1]; // Tách và lây token từ "Bearer token" if (invalidToken.includes(accessToken)) { // Nếu token đã hết hạn hoặc không hợp lệ thì trả về lỗi return res.status(401).json({ message: "AccessToken Invalid" }); } const decoded1 = jwt.verify(accessToken, "nguyendidan"); // Giải mã token next(); // Nếu token hợp lệ thì tiếp tục chạy middleware tiếp theo } catch (error) { // Nếu có lỗi trong quá trình giải mã token const typeError = error.message; // Lấy message của error // Nếu accessToken hết hạn => dùng refreshToken để tạo accessToken mới if (typeError === "jwt expired") { // Mã lỗi khi token hết hạn try { invalidToken.push(req.session.accessToken); // Thêm accessToken cũ vào mảng invalidToken const refreshToken = req.session.refreshToken; // Lấy refreshToken từ session (Hoặc từ cookie hoặc có thể từ database) const decoded2 = jwt.verify(refreshToken, "nguyendidan"); // Giải mã refreshToken const newAccessToken = genJWT.generateAccessToken({ userId: decoded2.userId, }); // Tạo accessToken mới với payload vừa giải mã từ refreshToken const newRefreshToken = genJWT.generateRefreshToken({ userId: decoded2.userId, }); // Tạo refreshToken mới với payload vừa giải mã từ refreshToken (xóa refreshToken cũ và tạo refreshToken mới) req.session.accessToken = newAccessToken; // Gán accessToken mới vào session req.session.refreshToken = newRefreshToken; // Gán accessToken mới vào session req.session.isLogin = true; // Gán isLogin = true để đánh dấu là đã đăng nhập req.session.save(() => { // Lưu lại session res.status(200).json({ message: "Done and created new AccessToken", accessToken: newAccessToken, userId: decoded2.userId, }); // Trả về accessToken mới }); // Lưu lại session } catch (error) { // Nếu có lỗi trong quá trình giải mã refreshToken req.session.destroy(() => { res.status(401).json({ message: "RefreshToken Invalid" }); // Nếu không xác thực được refreshToken thì trả về lỗi }); // Xóa session để đăng xuất } } else { // Nếu accessToken không hợp lệ => xóa session và chuyển hướng về trang login req.session.destroy(() => { res.status(401).json({ message: "AccessToken Invalid" }); // Nếu không xác thực được accessToken thì trả về lỗi }); // Xóa session để đăng xuất } } }; module.exports = ProtectRoute; ``` 3. Sử dụng `middleware` đặt trước các `route` cần bảo vệ, xác thực > File `route.js` ```javascript const express = require("express"); const route = express.Router(); const getAuth = require("../controllers/auth"); const ProtectRoute = require("../middleware/protectRoute"); // ... route.get("/", ProtectRoute, getAuth.getIndex); // Sử dụng middleware ProtectRoute ở đây để kiểm tra quyền truy cập của người dùng, nó sẽ chạy trước khi route được thực thi, nếu ok thì tiếp tục thực thi hàm sau đó module.exports = route; ```

NodeJS: Sử dụng Cookie, Session và Authentication