Mengirim data dari satu tempat ke tempat lain? Untuk ketenangan pikiran Anda sendiri, dan perlindungan pengguna Anda, Anda harus mengamankannya dengan JWT.

Saat Anda membuat aplikasi, penting bagi Anda untuk melindungi data sensitif dari akses tidak sah. Banyak aplikasi web, seluler, dan cloud modern menggunakan REST API sebagai alat komunikasi utama. Akibatnya, sangat penting untuk merancang dan mengembangkan API backend dengan keamanan di garis depan.

Salah satu pendekatan efektif untuk mengamankan REST API melibatkan JSON Web Token (JWT). Token ini menawarkan mekanisme yang kuat untuk autentikasi dan otorisasi pengguna, membantu melindungi sumber daya yang dilindungi dari akses oleh pelaku jahat.

Apa itu Token Web JSON?

Token Web JSON (JWT) adalah standar keamanan yang banyak digunakan. Ini menyediakan metode mandiri yang ringkas untuk mentransmisikan data dengan aman antara aplikasi klien dan sistem backend.

REST API dapat menggunakan JWT untuk mengidentifikasi dan mengautentikasi pengguna dengan aman saat mereka membuat permintaan HTTP untuk mengakses sumber daya yang dilindungi.

instagram viewer

Token Web JSON terdiri dari tiga bagian berbeda: header, payload, dan tanda tangan. Itu mengkodekan setiap bagian dan menggabungkannya menggunakan tanda titik (".").

Header menjelaskan algoritme kriptografi yang digunakan untuk menandatangani token, sedangkan payload berisi data tentang pengguna dan metadata tambahan apa pun.

Terakhir, tanda tangan, yang dihitung menggunakan header, payload, dan kunci rahasia, memastikan integritas dan keaslian token.

Dengan dasar-dasar JWT, mari kita membangun REST API Node.js dan mengimplementasikan JWT.

Menyiapkan Aplikasi Express.js dan Database MongoDB

Anda akan menemukan di sini cara membuat autentikasi sederhana API REST yang menangani fungsi registrasi dan login. Setelah proses login mengautentikasi pengguna, mereka harus dapat membuat permintaan HTTP ke rute API yang dilindungi.

Anda dapat menemukan kode proyek di sini repositori GitHub.

Untuk memulai, membuat server web Ekspres, dan instal paket-paket ini:

npm install cors dotenv bycrpt mongoose cookie-parser crypto jsonwebtoken mongodb

Berikutnya, membuat database MongoDB atau konfigurasikan cluster MongoDB di cloud. Kemudian salin string koneksi database, buat a .env file di direktori root, dan rekatkan di string koneksi:

CONNECTION_STRING="string koneksi"

Konfigurasi Koneksi Database

Buat yang baru utils/db.js file di direktori root folder proyek Anda. Dalam file ini, tambahkan kode berikut untuk membuat koneksi database menggunakan Mongoose.

const luwak = memerlukan('luwak');
const connectDB = asinkron () => {
mencoba {
menunggu mongoose.connect (process.env. CONNECTION_STRING);
menghibur.catatan("Terhubung ke MongoDB!");
 } menangkap (kesalahan) {
menghibur.kesalahan("Kesalahan menghubungkan ke MongoDB:", kesalahan);
 }
};
modul.ekspor = connectDB;

Tentukan Model Data

Tentukan skema data pengguna sederhana menggunakan Mongoose. Di direktori root, buat yang baru model/pengguna.model.js file dan tambahkan kode berikut.

const luwak = memerlukan('luwak');
const userSchema = baru luwak. Skema({
 nama belakang: Rangkaian,
 kata sandi: {
 jenis: Rangkaian,
 diperlukan: BENAR,
 unik: BENAR,
 },
});
const Pengguna = luwak.model("Pengguna", skema pengguna);
modul.ekspor = Pengguna;

Tentukan Pengontrol untuk Rute API

Fungsi pengontrol akan mengelola pendaftaran dan login; mereka adalah bagian penting dari contoh program ini. Di direktori root, buat a controllers/userControllers.js file dan tambahkan kode berikut:

  1. Tentukan pengontrol pendaftaran pengguna.
    const Pengguna = memerlukan('../model/pengguna.model');
    const bcrypt = memerlukan('bcrypt');
    const { generateToken } = memerlukan('../middleware/auth');
    ekspor.registerUser = asinkron (req, res) => {
    const { nama pengguna, kata sandi } = req.body;
    mencoba {
    const hash = menunggu bcrypt.hash (kata sandi, 10); 
    menunggu Pengguna.buat({ nama pengguna, kata sandi: hash});
     res.status(201).mengirim({ pesan: 'Pengguna berhasil terdaftar' });
     } menangkap (kesalahan) {
    menghibur.log (kesalahan);
     res.status(500).mengirim({ pesan: 'Terjadi kesalahan!! ' });
     }
    };
    Cuplikan kode ini mem-hash kata sandi yang diberikan menggunakan bcrypt dan kemudian membuat catatan pengguna baru di database, menyimpan nama pengguna dan kata sandi yang di-hash. Jika pendaftaran berhasil, ia mengirimkan respons dengan pesan sukses.
  2. Tetapkan pengontrol login untuk mengelola proses login pengguna:
    export.loginUser = asinkron (req, res) => {
    const { nama pengguna, kata sandi } = req.body;
    mencoba {
    const pengguna = menunggu Pengguna.findOne({ nama pengguna });

    jika (!pengguna) {
    kembali res.status(404).mengirim({ pesan: 'Pengguna tidak ditemukan' });
     }
    

    const passwordMatch = menunggu bcrypt.compare (kata sandi, pengguna.kata sandi);
    

    jika (!passwordMatch) {
    kembali res.status(401).mengirim({ pesan: 'Kredensial masuk tidak valid' });
     }
    const muatan = { identitas pengguna: identitas pengguna };
    const token = generateToken (muatan);
     res.cookie('token', token, { httpOnly: BENAR });
     res.status(200).json({ pesan: 'Login berhasil'});
     } menangkap (kesalahan) {
    menghibur.log (kesalahan);
     res.status(500).mengirim({ pesan: 'Terjadi kesalahan saat masuk' });
     }
    };
    Saat pengguna mengirim permintaan ke /login rute, mereka harus melewati kredensial otentikasi mereka di badan permintaan. Kode kemudian memverifikasi kredensial tersebut dan menghasilkan Token Web JSON. Token disimpan dengan aman dalam cookie dengan httpOnly bendera disetel ke true. Ini mencegah JavaScript sisi klien mengakses token, melindungi dari potensi serangan cross-site scripting (XSS).
  3. Terakhir, tentukan rute yang dilindungi:
    ekspor.getUsers = asinkron (req, res) => {
    mencoba {
    const pengguna = menunggu Pengguna.temukan({});
     res.json (pengguna);
     } menangkap (kesalahan) {
    menghibur.log (kesalahan);
     res.status(500).mengirim({ pesan: 'Terjadi kesalahan!!' });
     }
    };
    Dengan menyimpan JWT dalam cookie, permintaan API selanjutnya dari pengguna yang diautentikasi akan secara otomatis menyertakan token, memungkinkan server memvalidasi dan mengesahkan permintaan.

Buat Middleware Otentikasi

Sekarang setelah Anda menentukan pengontrol masuk yang menghasilkan token JWT setelah otentikasi berhasil, tentukan fungsi otentikasi middleware yang akan menghasilkan dan memverifikasi token JWT.

Di direktori root, buat folder baru, middleware. Di dalam folder ini, tambahkan dua file: auth.js Dan config.js.

Tambahkan kode ini ke config.js:

const kripto = memerlukan('kripto');
modul.ekspor = {
 secretKey: crypto.randomBytes(32).toString('hex')
};

Kode ini menghasilkan kunci rahasia acak baru setiap kali dijalankan. Anda kemudian dapat menggunakan kunci rahasia ini untuk menandatangani dan memverifikasi keaslian JWT. Setelah pengguna berhasil diautentikasi, buat dan tandatangani JWT dengan kunci rahasia. Server kemudian akan menggunakan kunci untuk memverifikasi bahwa JWT valid.

Tambahkan kode berikut di auth.js yang mendefinisikan fungsi middleware yang menghasilkan dan memverifikasi JWT.

const jwt = memerlukan('jsonwebtoken');
const { kunci rahasia } = memerlukan('./konfigurasi');
const generateToken = (muatan) => {
const token = jwt.tanda (muatan, secretKey, { kadaluarsa dalam: '1 jam' });
kembali tanda ;
};


const verifikasiToken = (req, res, selanjutnya) => {
const token = req.cookies.token;


jika (!token) {
kembali res.status(401).json({ pesan: 'Tidak ada token yang disediakan' });
 }


 jwt.verify (token, secretKey, (err, decode) => {
jika (salah) {
kembali res.status(401).json({ pesan: 'Token tidak valid' });
 }


 req.userId = decode.userId;
 Berikutnya();
 }); 
};
modul.ekspor = { generateToken, verifikasiToken };

Itu generateToken fungsi menghasilkan JWT dengan menandatangani payload menggunakan kunci rahasia dan mengatur waktu kedaluwarsa sementara verifikasiToken fungsi berfungsi sebagai middleware untuk memverifikasi keaslian dan validitas token yang disediakan.

Tentukan Rute API

Buat yang baru rute/userRoutes.js file di direktori root dan tambahkan kode berikut.

const mengungkapkan = memerlukan('cepat');
const router = ekspres. Perute();
const userController = memerlukan('../controllers/userControllers');
const {verifikasiToken} = memerlukan('../middleware/auth');
router.post('/api/daftar', userControllers.registerUser);
router.post('/api/masuk', userControllers.loginUser);
router.dapatkan('/api/pengguna', verifikasiToken, userControllers.getUsers);
modul.ekspor = perute;

Perbarui Titik Masuk Server Anda

Perbarui Anda server.js file dengan kode berikut.

const mengungkapkan = memerlukan('cepat');
const kor = memerlukan('kor');
const aplikasi = ekspres();
const pelabuhan = 5000;
memerlukan('dotenv'.config();
const connectDB = memerlukan('./utils/db');
const cookieParser = memerlukan('pengurai kue');
connectDB();


app.use (express.json());
app.use (express.urlencoded({ diperpanjang: BENAR }));
app.use (cors());
app.use (cookieParser());
const rute pengguna = memerlukan('./routes/userRoutes');
aplikasi.penggunaan('/', rute pengguna);
app.listen (port, () => {
menghibur.catatan(`Server mendengarkan di http://localhost:${port}`);
});

Untuk menguji REST API, aktifkan server pengembangan dan buat permintaan API ke titik akhir yang ditentukan:

simpul server.js

Mengamankan REST API Node.js

Mengamankan API REST Node.js lebih dari sekadar menggunakan JWT, meskipun JWT memainkan peran penting dalam autentikasi dan otorisasi, penting untuk mengadopsi pendekatan keamanan holistik terhadap keamanan untuk melindungi backend Anda sistem. Di samping JWT, Anda juga harus mempertimbangkan penerapan HTTPS untuk mengenkripsi komunikasi, validasi input dan sanitasi, dan banyak lainnya.

Dengan menggabungkan beberapa tindakan keamanan, Anda dapat membuat kerangka kerja keamanan yang kuat untuk Anda API REST Node.js dan meminimalkan risiko akses tidak sah, pelanggaran data, dan keamanan lainnya ancaman.