Menguasai Pengesahan Selamat dalam Node.js: Log Masuk/Keluar dengan bcrypt.js dan JWT-tutorial js-php.cn

Bayangkan anda sedang membina aplikasi web yang akan dilancarkan. Anda telah mereka bentuk antara muka pengguna dengan teliti, menambah ciri menarik dan memastikan semuanya berjalan lancar. Tetapi apabila tarikh pelancaran semakin hampir, kebimbangan yang mengganggu mula membimbangkan anda—keselamatan. Khususnya, bagaimana untuk memastikan bahawa hanya pengguna yang betul boleh mengakses bahagian aplikasi anda yang betul. Di sinilah pengesahan masuk.

Pengesahan ialah proses mengesahkan siapa pengguna dan ia merupakan aspek kritikal pembangunan web. Dalam landskap digital yang luas, memastikan pengguna boleh log masuk dan log keluar dengan selamat daripada aplikasi anda adalah yang paling penting. Satu slip, dan apl anda mungkin terdedah kepada serangan, meletakkan data pengguna pada risiko.

pengenalan

Dalam artikel ini, kami akan meneroka pengesahan selamat dalam Node.js, menggunakan bcrypt.js untuk mencincang kata laluan dan token JWT untuk mengurus sesi pengguna. Pada akhirnya, anda akan mempunyai pemahaman yang kukuh tentang cara melaksanakan sistem log masuk/log keluar yang kukuh, memastikan data pengguna anda selamat dan terjamin.

Jadi, mari kita mulakan perjalanan ini untuk membina sistem pengesahan kalis peluru, bermula daripada menyediakan persekitaran kita kepada memastikan laluan kita dengan JWT. Bersedia untuk mengunci apl Node.js anda? Mari mulakan.

Menyediakan Persekitaran Projek Node.js Anda

Mula-mula, mulakan projek Node.js anda dengan npm init -y, yang mencipta fail package.json dengan tetapan lalai. Seterusnya, pasang pakej penting: ekspres untuk menyediakan pelayan, mongoose untuk mengurus MongoDB, jsonwebtoken untuk mengendalikan token JWT, bcryptjs untuk mencincang kata laluan, dotenv untuk pembolehubah persekitaran, cors untuk mendayakan Perkongsian Sumber Silang Asal, penghurai kuki untuk menghuraikan kuki. Akhir sekali, tambahkan nodemon sebagai kebergantungan pembangunan untuk memulakan semula pelayan secara automatik apabila kod berubah.

1.`npm init -y`
2.`npm install express mongoose jsonwebtoken bcryptjs dotenv cors cookie-parser`
3.`npm install nodemon -D`

Salin selepas log masuk

Sekarang ubah suai fail package.json. Tambahkan skrip seperti kod dan taip saya.

"scripts": {
    "dev": "nodemon backend/index.js",
    "start": "node backend/index.js"
  },
"type": "module",

Salin selepas log masuk

Persediaan Pelayan Asas

Seterusnya, kami akan menyediakan pelayan Express asas. Buat fail bernama index.js . Kod ini memulakan Express dan mencipta contoh aplikasi. Kami kemudiannya akan menentukan laluan untuk URL akar ("/") untuk mengendalikan permintaan HTTP GET yang masuk. Selepas itu, kami akan memulakan pelayan pada port 8000, membenarkannya mendengar permintaan masuk.

import express from "express";
const app = express();

app.get("/", (req, res) => {
  res.send("Server is ready");
});

app.listen(8000, () => {
  console.log("Server is running on PORT 8000");
});

Salin selepas log masuk

Menyediakan Laluan Pengesahan Asas

Sekarang, kami akan mencipta folder bernama 'laluan' dan dalam folder itu kami akan membuat fail baharu bernama authRoute.js dan tampal kod di bawah untuk melihat asas laluan.

Dalam coretan kod ini, kami menyediakan laluan untuk titik akhir pengesahan yang berbeza menggunakan Express. Mula-mula, kami mengimport perpustakaan ekspres dan mencipta contoh penghala baharu. Kemudian, kami mentakrifkan tiga laluan GET: /signup, /login, dan /logout, masing-masing bertindak balas dengan objek JSON yang menunjukkan bahawa titik akhir masing-masing telah dipukul. Akhir sekali, kami mengeksport tika penghala sebagai eksport lalai, menjadikannya tersedia untuk digunakan di bahagian lain aplikasi.

1.`npm init -y`
2.`npm install express mongoose jsonwebtoken bcryptjs dotenv cors cookie-parser`
3.`npm install nodemon -D`

Salin selepas log masuk

Sekarang tukar index.js menambahkan laluan pengesahan untuk menguji titik akhir anda.

"scripts": {
    "dev": "nodemon backend/index.js",
    "start": "node backend/index.js"
  },
"type": "module",

Salin selepas log masuk

Kini, anda boleh mengujinya dalam pelayar anda...tetapi saya akan menggunakan Posmen untuk kemudahannya. Anda boleh menguji semua titik akhir seperti ini.

Mastering Secure Authentication in Node.js: Login/Logout with bcrypt.js and JWT

Begitu juga anda boleh melihat laluan lain seperti Log Keluar dan Daftar.

Jadi, apl asas kami sudah sedia...kini jadikan ia sebagai sistem pengesahan yang mantap dan betul.

Mencipta Model Pengguna dengan Skema Mongoose

Sekarang, sediakan pangkalan data mongoDB kami dahulu. Untuk berbuat demikian, buat folder Model dan di bawahnya fail User.js dan dalam fail ini tambahkan skema dan model Mongoose untuk Pengguna dalam pangkalan data mongoDB. Skema termasuk medan untuk nama pengguna, Nama penuh, kata laluan dan e-mel, masing-masing dengan jenis data dan kekangan tertentu seperti keunikan dan status yang diperlukan. Medan kata laluan juga mempunyai panjang minimum 6 aksara.

import express from "express";
const app = express();

app.get("/", (req, res) => {
  res.send("Server is ready");
});

app.listen(8000, () => {
  console.log("Server is running on PORT 8000");
});

Salin selepas log masuk

Menyambung ke MongoDB dengan Mongoose

Sekarang mari sambung ke pangkalan data kami. Kami akan mencipta folder bernama db dan di dalamnya, fail yang dipanggil connectDB.js. Dalam fail ini, kami akan mentakrifkan fungsi tak segerak connectMongoDB yang cuba menyambung ke pangkalan data MongoDB menggunakan Mongoose. Ia mendapat rentetan sambungan pangkalan data daripada pembolehubah persekitaran MONGO_URI. Jika sambungan berjaya, ia log mesej kejayaan dengan nama hos. Jika gagal, ia mencatat ralat dan keluar dari proses dengan kod status 1. Fungsi ini dieksport untuk digunakan di bahagian lain aplikasi.

import express from "express";

// Create a new Express router instance
const router = express.Router();

// Define a GET route for the signup endpoint
router.get("/signup", (req, res) => {
  // Return a JSON response indicating that the signup endpoint was hit
  res.json({
    data: "You hit signup endpoint",
  });
});

// Define a GET route for the login endpoint
router.get("/login", (req, res) => {
  // Return a JSON response indicating that the login endpoint was hit
  res.json({
    data: "You hit login endpoint",
  });
});

// Define a GET route for the logout endpoint
router.get("/logout", (req, res) => {
  // Return a JSON response indicating that the logout endpoint was hit
  res.json({
    data: "You hit logout endpoint",
  });
});

// Export the router instance as the default export
export default router;

Salin selepas log masuk

Sekarang untuk menggunakan MONGO_URI kita perlu membuatnya dalam fail .env. Di sini saya telah menggunakan rentetan sambungan persediaan mongoDB tempatan. Jika anda mahu, anda juga boleh menggunakan atlas mongoDB.

import express from "express";
import authRoute from "./routes/authRoutes.js";
const app = express();

app.get("/", (req, res) => {
  res.send("Server is ready");
});

app.use("/api/auth", authRoute);

app.listen(8000, () => {
  console.log("Server is running on PORT 8000");
});

Salin selepas log masuk

Fungsi pendaftaran

Sekarang buat fungsi pendaftaran. Untuk pertama kali ini buat pengawal folder dan di sana fail authController.js

import mongoose from "mongoose";

// Define the User schema with various fields and their data types
const userSchema = new mongoose.Schema(
  {
    // The unique username of the user
    username: {
      type: String,
      required: true,
      unique: true,
    },
    fullName: {
      type: String,
      required: true,
    },
    // The password of the user (min length: 6)
    password: {
      type: String,
      required: true,
      minLength: 6,
    },
    // The email of the user (unique)
    email: {
      type: String,
      required: true,
      unique: true,
    },
  },
  { timestamps: true }
);

// Create the User model based on the userSchema
const User = mongoose.model("User", userSchema);

// Export the User model
export default User;

Salin selepas log masuk

Pertama, ia mengekstrak Nama penuh, nama pengguna, e-mel dan kata laluan daripada badan permintaan. Ia mengesahkan format e-mel menggunakan ungkapan biasa, mengembalikan status 400 jika format tidak sah.

Seterusnya, fungsi menyemak sama ada nama pengguna atau e-mel sudah wujud dalam pangkalan data. Jika salah satu diambil, status 400 dengan mesej ralat dikembalikan. Ia juga memastikan kata laluan sekurang-kurangnya 6 aksara, menghantar 400 status lagi jika syarat ini tidak dipenuhi.

Kata laluan kemudiannya dicincang dengan selamat menggunakan bcrypt. Contoh Pengguna baharu dibuat dengan data yang disediakan dan disimpan ke pangkalan data.

Selepas menyimpan, fungsi menjana token JWT, menetapkannya sebagai kuki dan mengembalikan status 201 dengan ID pengguna, nama penuh, nama pengguna dan e-mel. Jika sebarang ralat berlaku, ia dilog dan status 500 dihantar dengan mesej "Ralat Pelayan Dalaman".

Untuk menjadikan fungsi ini aktif, anda perlu mengimportnya

1.`npm init -y`
2.`npm install express mongoose jsonwebtoken bcryptjs dotenv cors cookie-parser`
3.`npm install nodemon -D`

Salin selepas log masuk

Perhatikan sesuatu? perkara baharu yang dipanggil generateTokenAndSetCookie...mari lihat kodnya...buat folder utils dan di sana generateTokenAndSetCookie.js.

"scripts": {
    "dev": "nodemon backend/index.js",
    "start": "node backend/index.js"
  },
"type": "module",

Salin selepas log masuk

Fungsi **generateTokenAndSetCookie **mencipta JWT dan menyimpannya dalam kuki untuk pengesahan pengguna.

Generasi JWT:

Fungsi menggunakan perpustakaan jsonwebtoken untuk mencipta JWT. Ia menandatangani token dengan ID pengguna dan kunci rahsia (JWT_SECRET daripada pembolehubah persekitaran), menetapkannya untuk tamat tempoh dalam masa 15 hari.

Menetapkan Kuki:

Token kemudiannya disimpan dalam kuki pada penyemak imbas pengguna. Kuki dikonfigurasikan dengan beberapa atribut keselamatan:

maxAge: Tetapkan jangka hayat kuki kepada 15 hari.
httpSahaja: Memastikan kuki tidak boleh diakses melalui JavaScript, melindungi daripada serangan XSS (Cross-Site Scripting).
sameSite: "strict": Menghalang serangan CSRF (Cross-Site Request Forgery) dengan mengehadkan kuki untuk dihantar hanya dengan permintaan dari tapak yang sama.
selamat: Memastikan kuki hanya dihantar melalui HTTPS jika persekitaran tidak dibangunkan, menambah lapisan keselamatan tambahan.

Jadi fungsi ini memastikan sesi pengguna adalah selamat dan berterusan, menjadikannya bahagian penting dalam proses pengesahan.

Di sini kita perlu menambah satu lagi pembolehubah persekitaran JWT_SECRET dalam .env. Anda boleh menambah sebarang jenis campuran nombor dan rentetan seperti ini.

import express from "express";
const app = express();

app.get("/", (req, res) => {
  res.send("Server is ready");
});

app.listen(8000, () => {
  console.log("Server is running on PORT 8000");
});

Salin selepas log masuk

Sekarang fungsi signUp kami telah selesai..jadi buat laluannya sekarang.

import express from "express";

// Create a new Express router instance
const router = express.Router();

// Define a GET route for the signup endpoint
router.get("/signup", (req, res) => {
  // Return a JSON response indicating that the signup endpoint was hit
  res.json({
    data: "You hit signup endpoint",
  });
});

// Define a GET route for the login endpoint
router.get("/login", (req, res) => {
  // Return a JSON response indicating that the login endpoint was hit
  res.json({
    data: "You hit login endpoint",
  });
});

// Define a GET route for the logout endpoint
router.get("/logout", (req, res) => {
  // Return a JSON response indicating that the logout endpoint was hit
  res.json({
    data: "You hit logout endpoint",
  });
});

// Export the router instance as the default export
export default router;

Salin selepas log masuk

ok, sekarang mari ubah suai index.js kami Di sini kami menambah beberapa import baharu. dotenv: Memuatkan pembolehubah persekitaran dengan selamat daripada .env; express.json(): Menghuraikan permintaan JSON yang masuk; express.urlencoded({ extended: true }): Menghuraikan data yang dikodkan URL; cookieParser: Mengendalikan kuki untuk token JWT; connectMongoDB(): Menyambung ke MongoDB untuk penyimpanan data; Laluan: /api/auth menguruskan pendaftaran, log masuk dan log keluar.

Berikut ialah kod index.js yang dikemas kini

1.`npm init -y`
2.`npm install express mongoose jsonwebtoken bcryptjs dotenv cors cookie-parser`
3.`npm install nodemon -D`

Salin selepas log masuk

Jadi. kini tiba masanya untuk menguji fungsi pendaftaran kami dalam Posmen. Mari lihat sama ada ia berfungsi atau tidak.

Jadi, inilah hasilnya.

Mastering Secure Authentication in Node.js: Login/Logout with bcrypt.js and JWT

Di sini anda boleh melihat ia berfungsi dengan betul dan anda boleh menyemaknya juga pangkalan data mongoDB anda.

Mastering Secure Authentication in Node.js: Login/Logout with bcrypt.js and JWT

Fungsi log masuk

Sekarang buat fungsi log masuk. Mari pergi lagi ke fail authController.js kami

"scripts": {
    "dev": "nodemon backend/index.js",
    "start": "node backend/index.js"
  },
"type": "module",

Salin selepas log masuk

Pengawal log masuk mengesahkan pengguna dengan mengesahkan nama pengguna dan kata laluan mereka. Ia mula-mula mencari pengguna dalam pangkalan data menggunakan nama pengguna. Jika ditemui, ia membandingkan kata laluan yang disediakan dengan kata laluan cincang yang disimpan dalam pangkalan data menggunakan bcrypt. Jika nama pengguna atau kata laluan tidak betul, ia mengembalikan respons ralat. Apabila pengesahan berjaya, ia menjana token JWT, menetapkannya sebagai kuki menggunakan generateTokenAndSetCookie dan membalas dengan mesej kejayaan, menunjukkan pengguna berjaya log masuk.

Mari tambahkan laluan log masuk kami dalam authRoutes.js

import express from "express";
const app = express();

app.get("/", (req, res) => {
  res.send("Server is ready");
});

app.listen(8000, () => {
  console.log("Server is running on PORT 8000");
});

Salin selepas log masuk

Jom uji dalam Posmen.

Mastering Secure Authentication in Node.js: Login/Logout with bcrypt.js and JWT
Di sini anda boleh melihat ia berjaya menunjukkan Log masuk.

Fungsi log keluar

Baiklah. Sekarang fungsi terakhir iaitu fungsi log keluar. Mari kita laksanakan ini. Ia agak mudah.

import express from "express";

// Create a new Express router instance
const router = express.Router();

// Define a GET route for the signup endpoint
router.get("/signup", (req, res) => {
  // Return a JSON response indicating that the signup endpoint was hit
  res.json({
    data: "You hit signup endpoint",
  });
});

// Define a GET route for the login endpoint
router.get("/login", (req, res) => {
  // Return a JSON response indicating that the login endpoint was hit
  res.json({
    data: "You hit login endpoint",
  });
});

// Define a GET route for the logout endpoint
router.get("/logout", (req, res) => {
  // Return a JSON response indicating that the logout endpoint was hit
  res.json({
    data: "You hit logout endpoint",
  });
});

// Export the router instance as the default export
export default router;

Salin selepas log masuk

Pengawal log keluar dengan selamat melog keluar pengguna dengan mengosongkan kuki JWT daripada penyemak imbas pelanggan menggunakan res.cookie, menetapkan nilainya kepada rentetan kosong dan maxAgenya kepada 0, memastikan tamat tempoh serta-merta. Setelah pembersihan kuki berjaya, ia menghantar respons kejayaan dengan mesej yang menunjukkan pengguna berjaya log keluar. Jika sebarang ralat berlaku semasa proses ini, ia menangkap ralat itu, mencatatnya dan mengembalikan respons Ralat Pelayan Dalaman.

Tambahkan laluan ini pada authRoute.js
kami

import express from "express";
import authRoute from "./routes/authRoutes.js";
const app = express();

app.get("/", (req, res) => {
  res.send("Server is ready");
});

app.use("/api/auth", authRoute);

app.listen(8000, () => {
  console.log("Server is running on PORT 8000");
});

Salin selepas log masuk

okay. Mari uji ciri terakhir kami, jika ia berfungsi dengan baik atau tidak.

Mastering Secure Authentication in Node.js: Login/Logout with bcrypt.js and JWT

Oh!…Ia berfungsi dengan sangat baik. ??

Jadi, kini bahagian belakang lengkap kami bagi pengesahan ini sudah sedia. ??

Pakej npm saya

Jika anda tidak mahu mengodkan semuanya sendiri dan mahukan penyelesaian pantas, saya telah mencipta pakej npm yang dipanggil auth0_package. Anda boleh mendapatkannya dari sini.

Repositori Github

Anda boleh mendapatkan semua kod saya di atas di sini dalam repo github ini di sini.

Kini permohonan bahagian belakang anda telah selesai. Dalam blog seterusnya, saya akan menerangkan cara mengintegrasikan ini dengan bahagian hadapan anda. Jadi nantikan untuk itu ??.

Kesimpulan

Kesimpulannya, melaksanakan pengesahan selamat dalam aplikasi Node.js adalah penting untuk melindungi data pengguna dan memastikan bahawa hanya pengguna yang diberi kuasa boleh mengakses bahagian tertentu aplikasi anda. Dengan menggunakan bcrypt.js untuk pencincangan kata laluan dan token JWT untuk pengurusan sesi, anda boleh mencipta sistem log masuk/log keluar yang teguh. Pendekatan ini bukan sahaja meningkatkan keselamatan tetapi juga menyediakan pengalaman pengguna yang lancar. Menyediakan pangkalan data MongoDB dan menggunakan Express untuk penghalaan mengukuhkan lagi infrastruktur bahagian belakang. Dengan alatan dan teknik ini, anda boleh melancarkan aplikasi web anda dengan yakin, kerana mengetahui bahawa ia dilindungi dengan baik daripada akses tanpa kebenaran dan potensi ancaman keselamatan.

Atas ialah kandungan terperinci Menguasai Pengesahan Selamat dalam Node.js: Log Masuk/Keluar dengan bcrypt.js dan JWT. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!