Dalam era digital ini, keamanan aplikasi menjadi prioritas utama. Aplikasi web modern membutuhkan sistem otentikasi yang kuat dan aman. Laravel, sebagai framework PHP yang populer, menyediakan berbagai pilihan untuk mengimplementasikan sistem otentikasi. Salah satu solusi yang handal dan modern adalah menggunakan Laravel Sanctum. Tutorial ini akan memandu Anda langkah demi langkah bagaimana mengimplementasikan authentication dengan Laravel Sanctum dan bagaimana keamanan aplikasi Anda terjamin. Jadi, siapkan kopi Anda dan mari kita mulai!
1. Apa Itu Laravel Sanctum dan Mengapa Penting?
Laravel Sanctum adalah package ringan yang menyediakan sistem otentikasi berbasis token API untuk aplikasi Laravel Anda. Bayangkan Anda memiliki aplikasi yang digunakan oleh aplikasi mobile, aplikasi React, atau bahkan aplikasi Vue.js. Sanctum memudahkan autentikasi pengguna dari berbagai sumber ini dengan aman.
Keunggulan Laravel Sanctum:
- Ringan dan Mudah Digunakan: Sanctum relatif mudah dikonfigurasi dan diintegrasikan ke dalam proyek Laravel Anda.
- Autentikasi Berbasis Token API: Menggunakan token API sebagai pengganti cookie tradisional, memberikan fleksibilitas yang lebih besar untuk aplikasi lintas platform.
- Stateful dan Stateless Authentication: Sanctum mendukung autentikasi stateful (menggunakan session cookies) dan stateless (menggunakan token API), memungkinkan Anda memilih pendekatan yang paling sesuai dengan kebutuhan aplikasi Anda.
- Keamanan Terjamin: Dirancang dengan mempertimbangkan keamanan, Sanctum membantu melindungi aplikasi Anda dari serangan umum seperti CSRF (Cross-Site Request Forgery).
- Single Page Application (SPA) Friendly: Sanctum sangat cocok untuk SPA yang berinteraksi dengan backend Laravel melalui API.
- Mobile App Support: Sangat baik digunakan untuk autentikasi pengguna dari aplikasi mobile.
Dengan menggunakan Laravel Sanctum, Anda tidak perlu lagi khawatir tentang membangun sistem otentikasi yang kompleks dari awal. Sanctum menyediakan solusi yang elegan dan teruji untuk kebutuhan otentikasi Anda.
2. Persiapan Awal: Instalasi Laravel dan Sanctum
Sebelum kita mulai mengimplementasikan authentication dengan Sanctum, pastikan Anda sudah memiliki proyek Laravel yang sudah berjalan. Jika belum, mari kita buat proyek Laravel baru dan menginstal Sanctum.
Langkah 1: Buat Proyek Laravel Baru
Buka terminal atau command prompt Anda, kemudian jalankan perintah berikut:
composer create-project --prefer-dist laravel/laravel tutorial-sanctum
cd tutorial-sanctumPerintah ini akan membuat proyek Laravel baru dengan nama tutorial-sanctum. Pastikan Anda sudah memiliki Composer terinstall di sistem Anda.
Langkah 2: Konfigurasi Database
Konfigurasi koneksi database Anda di file .env. Sesuaikan nilai-nilai berikut sesuai dengan pengaturan database Anda:
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=tutorial_sanctum
DB_USERNAME=root
DB_PASSWORD=Jangan lupa untuk membuat database dengan nama tutorial_sanctum di server database Anda.
Langkah 3: Instal Laravel Sanctum
Setelah proyek Laravel selesai dibuat dan database sudah dikonfigurasi, sekarang saatnya untuk menginstal Laravel Sanctum. Jalankan perintah berikut di terminal:
composer require laravel/sanctumLangkah 4: Publikasikan Konfigurasi dan Migrasi Sanctum
Setelah instalasi selesai, publikasikan file konfigurasi dan migrasi Sanctum dengan perintah berikut:
php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider"Perintah ini akan menyalin file konfigurasi Sanctum ke direktori config/sanctum.php dan file migrasi ke direktori database/migrations.
Langkah 5: Jalankan Migrasi Database
Terakhir, jalankan migrasi database untuk membuat tabel yang dibutuhkan oleh Sanctum:
php artisan migratePastikan migrasi berjalan dengan sukses. Jika ada error, periksa kembali konfigurasi database Anda.
3. Konfigurasi Model User untuk Autentikasi Sanctum
Setelah Sanctum terinstall, kita perlu memodifikasi model User agar mendukung autentikasi menggunakan token.
Langkah 1: Tambahkan HasApiTokens Trait ke Model User
Buka file app/Models/User.php dan tambahkan HasApiTokens trait dari Sanctum ke model User:
<?php
namespace AppModels;
use IlluminateContractsAuthMustVerifyEmail;
use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateFoundationAuthUser as Authenticatable;
use IlluminateNotificationsNotifiable;
use LaravelSanctumHasApiTokens;
class User extends Authenticatable
{
use HasApiTokens, HasFactory, Notifiable;
// ... (kode lainnya)
}HasApiTokens trait menyediakan methods yang dibutuhkan untuk mengelola token API untuk pengguna.
Langkah 2: Sesuaikan fillable dan hidden Properties (Opsional)
Pastikan atribut yang ingin Anda izinkan untuk diisi (fillable) dan atribut yang ingin disembunyikan (hidden) sudah sesuai dengan kebutuhan aplikasi Anda. Contoh:
<?php
namespace AppModels;
use IlluminateContractsAuthMustVerifyEmail;
use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateFoundationAuthUser as Authenticatable;
use IlluminateNotificationsNotifiable;
use LaravelSanctumHasApiTokens;
class User extends Authenticatable
{
use HasApiTokens, HasFactory, Notifiable;
/**
* The attributes that are mass assignable.
*
* @var array<int, string>
*/
protected $fillable = [
'name',
'email',
'password',
];
/**
* The attributes that should be hidden for serialization.
*
* @var array<int, string>
*/
protected $hidden = [
'password',
'remember_token',
];
/**
* The attributes that should be cast.
*
* @var array<string, string>
*/
protected $casts = [
'email_verified_at' => 'datetime',
];
}4. Membuat API Endpoint untuk Registrasi dan Login dengan Sanctum
Sekarang kita akan membuat API endpoint untuk registrasi dan login pengguna menggunakan Sanctum.
Langkah 1: Buat Controller AuthController
Buat controller baru dengan nama AuthController menggunakan perintah berikut:
php artisan make:controller AuthControllerLangkah 2: Implementasikan Method register dan login
Buka file app/Http/Controllers/AuthController.php dan tambahkan kode berikut:
<?php
namespace AppHttpControllers;
use AppModelsUser;
use IlluminateHttpRequest;
use IlluminateSupportFacadesHash;
use IlluminateSupportFacadesValidator;
class AuthController extends Controller
{
public function register(Request $request)
{
$validator = Validator::make($request->all(), [
'name' => 'required|string|max:255',
'email' => 'required|string|email|max:255|unique:users',
'password' => 'required|string|min:8',
]);
if ($validator->fails()) {
return response()->json(['errors' => $validator->errors()], 422);
}
$user = User::create([
'name' => $request->name,
'email' => $request->email,
'password' => Hash::make($request->password),
]);
$token = $user->createToken('auth_token')->plainTextToken;
return response()->json([
'access_token' => $token,
'token_type' => 'Bearer',
]);
}
public function login(Request $request)
{
$validator = Validator::make($request->all(), [
'email' => 'required|string|email',
'password' => 'required|string',
]);
if ($validator->fails()) {
return response()->json(['errors' => $validator->errors()], 422);
}
$user = User::where('email', $request->email)->first();
if (!$user || !Hash::check($request->password, $user->password)) {
return response()->json([
'message' => 'Invalid login credentials'
], 401);
}
$token = $user->createToken('auth_token')->plainTextToken;
return response()->json([
'access_token' => $token,
'token_type' => 'Bearer',
]);
}
public function logout(Request $request) {
$request->user()->tokens()->delete();
return response()->json([
'message' => 'Successfully logged out'
]);
}
}Penjelasan Kode:
register(Request $request): Menerima data registrasi dari request, melakukan validasi, membuat user baru, dan mengembalikan token API.login(Request $request): Menerima data login dari request, melakukan validasi, memeriksa kredensial user, dan mengembalikan token API jika kredensial valid.logout(Request $request): Menghapus semua token user yang sedang aktif.
Langkah 3: Definisikan Route API
Buka file routes/api.php dan tambahkan route untuk registrasi dan login:
<?php
use AppHttpControllersAuthController;
use IlluminateHttpRequest;
use IlluminateSupportFacadesRoute;
Route::post('/register', [AuthController::class, 'register']);
Route::post('/login', [AuthController::class, 'login']);
Route::middleware('auth:sanctum')->group(function () {
Route::get('/user', function (Request $request) {
return $request->user();
});
Route::post('/logout', [AuthController::class, 'logout']);
});Penjelasan Kode:
/registerdan/logindiakses tanpa autentikasi./userdan/logoutdilindungi oleh middlewareauth:sanctum, yang berarti hanya user yang sudah terautentikasi (memiliki token yang valid) yang dapat mengakses endpoint ini.
5. Menguji API Authentication dengan Postman atau Insomnia
Sekarang mari kita uji API endpoint yang sudah kita buat menggunakan Postman atau Insomnia.
Langkah 1: Registrasi User
Buka Postman atau Insomnia, buat request POST ke http://localhost:8000/api/register (sesuaikan dengan port aplikasi Anda). Kirim data berikut dalam format JSON:
{
"name": "John Doe",
"email": "[email protected]",
"password": "password123"
}Jika berhasil, Anda akan menerima response JSON yang berisi access_token dan token_type. Simpan access_token ini, karena akan kita gunakan untuk mengakses endpoint yang dilindungi.
Langkah 2: Login User
Buat request POST ke http://localhost:8000/api/login. Kirim data berikut dalam format JSON:
{
"email": "[email protected]",
"password": "password123"
}Jika berhasil, Anda juga akan menerima response JSON yang berisi access_token dan token_type.
Langkah 3: Mengakses Endpoint yang Dilindungi
Buat request GET ke http://localhost:8000/api/user. Pada header request, tambahkan header Authorization dengan nilai Bearer <access_token>. Ganti <access_token> dengan token yang Anda dapatkan dari proses registrasi atau login.
Jika berhasil, Anda akan menerima response JSON yang berisi data user yang sedang login.
Langkah 4: Logout User
Buat request POST ke http://localhost:8000/api/logout. Pada header request, tambahkan header Authorization dengan nilai Bearer <access_token>.
Jika berhasil, Anda akan menerima response JSON dengan pesan Successfully logged out. Coba akses kembali endpoint /api/user. Anda seharusnya mendapatkan error karena token sudah tidak valid.
6. Implementasi Middleware Sanctum untuk Proteksi Route
Middleware auth:sanctum memainkan peran penting dalam melindungi route API Anda. Tanpa middleware ini, semua orang dapat mengakses endpoint Anda, yang tentunya sangat berbahaya.
Bagaimana Middleware auth:sanctum Bekerja?
Middleware auth:sanctum akan memeriksa header Authorization pada setiap request. Jika header tersebut ada dan berisi token yang valid, middleware akan mengautentikasi user berdasarkan token tersebut dan menetapkan objek user ke request. Jika header Authorization tidak ada atau token tidak valid, middleware akan mengembalikan error 401 Unauthorized.
Contoh Penggunaan Middleware pada Controller
Selain menggunakan middleware pada routes/api.php, Anda juga dapat menggunakannya langsung di controller.
<?php
namespace AppHttpControllers;
use IlluminateHttpRequest;
class UserController extends Controller
{
public function __construct()
{
$this->middleware('auth:sanctum');
}
public function index()
{
// Hanya user yang terautentikasi yang dapat mengakses method ini
return response()->json(auth()->user());
}
}Dalam contoh di atas, hanya user yang sudah terautentikasi yang dapat mengakses method index di UserController.
7. Keamanan Tambahan: Rate Limiting dan Sanitasi Input
Selain Sanctum, Anda juga perlu mempertimbangkan langkah-langkah keamanan tambahan untuk melindungi aplikasi Anda.
Rate Limiting
Rate limiting membatasi jumlah request yang dapat dilakukan oleh user dalam periode waktu tertentu. Ini membantu mencegah serangan brute-force dan DDoS (Distributed Denial of Service).
Laravel menyediakan middleware throttle untuk mengimplementasikan rate limiting. Anda dapat menerapkannya pada route API Anda:
Route::middleware('throttle:60,1')->group(function () {
Route::post('/login', [AuthController::class, 'login']);
Route::post('/register', [AuthController::class, 'register']);
});Kode di atas membatasi user untuk melakukan maksimal 60 request ke endpoint /login dan /register per menit.
Sanitasi Input
Selalu sanitasi input yang diterima dari user untuk mencegah serangan XSS (Cross-Site Scripting) dan SQL Injection. Gunakan fungsi strip_tags() atau htmlspecialchars() untuk membersihkan input sebelum menyimpannya ke database.
Anda juga dapat menggunakan library seperti HTMLPurifier untuk sanitasi input yang lebih kompleks.
8. Refresh Token: Memberikan Pengalaman Pengguna yang Lebih Baik
Token API memiliki masa berlaku. Setelah masa berlaku habis, user harus melakukan login ulang untuk mendapatkan token baru. Namun, kita dapat meningkatkan pengalaman pengguna dengan mengimplementasikan refresh token.
Refresh token adalah token khusus yang digunakan untuk mendapatkan token akses baru tanpa mengharuskan user memasukkan kredensial mereka lagi.
Implementasi Refresh Token (Contoh Sederhana)
Implementasi refresh token agak lebih kompleks dan memerlukan penyimpanan refresh token di database. Berikut adalah contoh sederhana konsepnya:
- Simpan Refresh Token: Saat login, selain membuat access token, buat juga refresh token dan simpan ke database bersama dengan ID user.
- Endpoint Refresh Token: Buat endpoint
/api/refresh-tokenyang menerima refresh token sebagai input. - Validasi Refresh Token: Di endpoint ini, validasi refresh token. Jika valid, buat access token baru dan refresh token baru. Update database dengan refresh token yang baru.
- Kembalikan Token Baru: Kembalikan access token dan refresh token yang baru ke user.
Catatan: Implementasi refresh token harus dilakukan dengan hati-hati untuk memastikan keamanan. Pertimbangkan untuk menggunakan library atau package yang sudah ada untuk mengelola refresh token dengan aman.
9. Menerapkan Kebijakan Password yang Kuat
Keamanan password merupakan aspek krusial dalam authentication. Pastikan Anda menerapkan kebijakan password yang kuat untuk melindungi akun user.
Rekomendasi Kebijakan Password:
- Panjang Minimum: Minimal 8 karakter, lebih baik 12 karakter atau lebih.
- Kompleksitas: Kombinasi huruf besar, huruf kecil, angka, dan simbol.
- Jangan Menggunakan Informasi Pribadi: Hindari penggunaan nama, tanggal lahir, atau informasi pribadi lainnya dalam password.
- Periksa Kebocoran Password: Gunakan API seperti Have I Been Pwned (HIBP) untuk memeriksa apakah password yang dimasukkan user pernah bocor.
Anda dapat menggunakan validasi rule di Laravel untuk menerapkan kebijakan password:
$validator = Validator::make($request->all(), [
'password' => [
'required',
'string',
'min:8', // Harus minimal 8 karakter
'regex:/[a-z]/', // Harus mengandung setidaknya 1 huruf kecil
'regex:/[A-Z]/', // Harus mengandung setidaknya 1 huruf besar
'regex:/[0-9]/', // Harus mengandung setidaknya 1 angka
'regex:/[@$!%*#?&]/', // Harus mengandung setidaknya 1 simbol
],
]);10. Menggunakan API Token dengan Scopes (Optional)
Laravel Sanctum memungkinkan Anda memberikan scopes (izin) pada token API. Scopes memungkinkan Anda mengontrol apa yang dapat dilakukan oleh user dengan token tersebut. Ini berguna jika Anda ingin memberikan akses terbatas ke API Anda.
Contoh Penggunaan Scopes
Misalkan Anda memiliki API untuk mengelola postingan blog. Anda ingin memberikan akses kepada beberapa user untuk membuat postingan, tetapi tidak untuk menghapus postingan. Anda dapat membuat scope create-posts dan memberikan scope tersebut hanya kepada user yang berhak.
Langkah 1: Definisikan Scopes
Saat membuat token, tentukan scope yang ingin diberikan:
$token = $user->createToken('auth_token', ['create-posts'])->plainTextToken;Langkah 2: Periksa Scopes pada Middleware
Gunakan middleware abilities untuk memeriksa apakah token memiliki scope yang dibutuhkan:
Route::middleware(['auth:sanctum', 'abilities:create-posts'])->group(function () {
Route::post('/posts', [PostController::class, 'store']);
});Hanya token yang memiliki scope create-posts yang dapat mengakses endpoint /posts.
11. Pentingnya Log Aktivitas Pengguna
Mencatat aktivitas pengguna (user activity logging) adalah praktik keamanan penting yang sering diabaikan. Dengan mencatat aktivitas pengguna, Anda dapat memantau perilaku pengguna, mendeteksi aktivitas mencurigakan, dan mengaudit sistem Anda.
Informasi yang Perlu Dicatat:
- Waktu Kejadian: Kapan aktivitas terjadi.
- User yang Melakukan Aktivitas: Siapa yang melakukan aktivitas.
- Jenis Aktivitas: Apa yang dilakukan (misalnya: login, logout, membuat postingan, menghapus user).
- Data yang Terkait dengan Aktivitas: Data yang terlibat dalam aktivitas (misalnya: ID postingan yang dibuat, ID user yang dihapus).
- IP Address: Alamat IP dari mana aktivitas dilakukan.
Cara Mengimplementasikan Log Aktivitas
Anda dapat mengimplementasikan log aktivitas dengan membuat tabel activity_logs di database Anda dan menyimpan informasi aktivitas ke tabel tersebut setiap kali terjadi aktivitas yang relevan.
Ada juga package Laravel yang dapat membantu Anda mengimplementasikan log aktivitas dengan mudah, seperti spatie/laravel-activitylog.
12. Kesimpulan: Keamanan Aplikasi Laravel Anda di Tangan Anda
Selamat! Anda telah mempelajari cara mengimplementasikan authentication dengan Laravel Sanctum dan berbagai langkah keamanan tambahan untuk melindungi aplikasi Anda. Ingatlah bahwa keamanan adalah proses berkelanjutan. Teruslah belajar dan menerapkan praktik keamanan terbaik untuk memastikan keamanan aplikasi Anda. Dengan Tutorial Authentication Laravel dengan Sanctum, keamanan aplikasi Anda terjamin. Jangan ragu untuk terus bereksperimen dan menjelajahi fitur-fitur lain dari Laravel dan Sanctum untuk meningkatkan keamanan dan fungsionalitas aplikasi Anda.
