Mengamankan API dengan Tokenisasi

From OnnoWiki
Jump to navigation Jump to search
  1. Modul 3.3: Mengamankan API dengan Tokenisasi
    1. Pendahuluan

Dalam pengembangan aplikasi web, keamanan komunikasi antara klien dan server menjadi aspek krusial. Salah satu metode yang umum digunakan untuk mengamankan komunikasi tersebut adalah melalui **tokenisasi**, khususnya dengan implementasi **JSON Web Tokens (JWT)**. JWT memungkinkan autentikasi dan otorisasi yang aman tanpa perlu menyimpan status sesi di server, menjadikannya pilihan populer dalam pengembangan API modern.

    1. Apa Itu JSON Web Token (JWT)?
    • JSON Web Token (JWT)** adalah standar terbuka (RFC 7519) yang mendefinisikan cara aman untuk mentransmisikan informasi antara pihak-pihak sebagai objek JSON. Informasi ini dapat diverifikasi dan dipercaya karena ditandatangani secara digital. JWT terdiri dari tiga bagian utama:

1. **Header**: Berisi tipe token dan algoritma yang digunakan, seperti HMAC SHA256 atau RSA. 2. **Payload**: Berisi klaim atau pernyataan tentang entitas (biasanya pengguna) dan data tambahan lainnya. 3. **Signature**: Digunakan untuk memverifikasi bahwa pesan tidak diubah selama transmisi.

Struktur JWT secara umum adalah sebagai berikut:

```

Header.Payload.Signature ``` 

Setiap bagian dienkode dalam Base64URL dan dipisahkan oleh titik.

    1. Instalasi Flask dan Flask-JWT-Extended di Ubuntu 24.04

Sebelum memulai implementasi, pastikan Anda telah menginstal Python 3 dan pip. Berikut langkah-langkah instalasi Flask dan Flask-JWT-Extended:

1. **Perbarui daftar paket dan instal dependensi yang diperlukan:** 

  ```bash
  sudo apt update
  sudo apt install python3 python3-pip python3-venv -y
  ```

2. **Buat direktori proyek dan navigasikan ke dalamnya:** 

  ```bash
  mkdir flask_jwt_api
  cd flask_jwt_api
  ```

3. **Buat dan aktifkan virtual environment:** 

  ```bash
  python3 -m venv venv
  source venv/bin/activate
  ```

4. **Instal Flask dan Flask-JWT-Extended:** 

  ```bash
  pip install Flask Flask-JWT-Extended
  ```

    1. Implementasi JSON Web Token (JWT) dalam Flask

Setelah instalasi, kita akan mengimplementasikan JWT untuk mengamankan API dalam aplikasi Flask.

1. **Konfigurasi Aplikasi Flask:** 

  Buat file `app.py` dan tambahkan kode berikut:

  ```python
  from flask import Flask, jsonify, request
  from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jwt_identity

  app = Flask(__name__)

  # Konfigurasi kunci rahasia untuk JWT
  app.config['JWT_SECRET_KEY'] = 'kunci_rahasia_anda'
  jwt = JWTManager(app)

  if __name__ == '__main__':
      app.run(debug=True)
  ```


  Kode di atas menginisialisasi aplikasi Flask dan mengkonfigurasi kunci rahasia untuk JWT.

2. **Membuat Endpoint untuk Autentikasi Pengguna:** 

  Tambahkan route untuk login yang menghasilkan token JWT:

  ```python
  from werkzeug.security import check_password_hash

  # Data pengguna contoh
  users = {
      "user1": {
          "password": "hashed_password1"
      },
      "user2": {
          "password": "hashed_password2"
      }
  }

  @app.route('/login', methods=['POST'])
  def login():
      username = request.json.get('username', None)
      password = request.json.get('password', None)

      user = users.get(username, None)
      if user and check_password_hash(user['password'], password):
          access_token = create_access_token(identity=username)
          return jsonify(access_token=access_token), 200
      else:
          return jsonify({"msg": "Username atau password salah"}), 401
  ```


  Dalam contoh ini, `users` adalah kamus yang menyimpan data pengguna dengan password yang telah di-hash. Fungsi `check_password_hash` digunakan untuk memverifikasi password yang dimasukkan dengan hash yang tersimpan.

3. **Membuat Endpoint yang Dilindungi:** 

  Tambahkan route yang hanya dapat diakses dengan token JWT yang valid:

  ```python
  @app.route('/protected', methods=['GET'])
  @jwt_required()
  def protected():
      current_user = get_jwt_identity()
      return jsonify(logged_in_as=current_user), 200
  ```


  Dekorator `@jwt_required()` memastikan bahwa endpoint ini hanya dapat diakses jika permintaan menyertakan token JWT yang valid.

4. **Menjalankan Aplikasi:** 

  Jalankan aplikasi Flask dengan perintah:

  ```bash
  python app.py
  ```


  Aplikasi akan berjalan di `http://127.0.0.1:5000/`.
    1. Pengujian API dengan cURL

Untuk menguji endpoint yang telah dibuat, Anda dapat menggunakan cURL:

1. **Melakukan Login untuk Mendapatkan Token:** 

  ```bash
  curl -X POST http://127.0.0.1:5000/login \
  -H "Content-Type: application/json" \
  -d '{"username": "user1", "password": "password1"}'
  ```


  Jika berhasil, Anda akan menerima respons dengan token akses.

2. **Mengakses Endpoint yang Dilindungi:** 

  Gantilah `your_access_token` dengan token yang diperoleh dari langkah sebelumnya.

  ```bash
  curl -X GET http://127.0.0.1:5000/protected \
  -H "Authorization: Bearer your_access_token"
  ```


  Jika token valid, Anda akan menerima respons



Melanjutkan pembahasan sebelumnya mengenai pengamanan API dengan JSON Web Token (JWT) dalam aplikasi Flask, kita akan membahas lebih lanjut tentang pengelolaan token, penanganan kesalahan, dan praktik terbaik dalam implementasi JWT.

    1. 1. Penggunaan Refresh Token

Selain **access token**, JWT juga mendukung penggunaan **refresh token**. Access token biasanya memiliki masa berlaku yang singkat untuk mengurangi risiko jika token tersebut dicuri. Setelah access token kedaluwarsa, refresh token digunakan untuk mendapatkan access token baru tanpa perlu meminta pengguna untuk login kembali.

    • Implementasi Refresh Token dalam Flask:**

Tambahkan konfigurasi berikut pada aplikasi Flask Anda:


```python from flask_jwt_extended import create_refresh_token, jwt_refresh_token_required

  1. Endpoint untuk login yang menghasilkan access dan refresh token

@app.route('/login', methods=['POST']) def login(): 

   username = request.json.get('username')
   password = request.json.get('password')
   user = users.get(username)
   if user and check_password_hash(user['password'], password):
       access_token = create_access_token(identity=username)
       refresh_token = create_refresh_token(identity=username)
       return jsonify(access_token=access_token, refresh_token=refresh_token), 200
   return jsonify({"msg": "Username atau password salah"}), 401
  1. Endpoint untuk mendapatkan access token baru menggunakan refresh token

@app.route('/refresh', methods=['POST']) @jwt_refresh_token_required def refresh(): 

   current_user = get_jwt_identity()
   new_access_token = create_access_token(identity=current_user)
   return jsonify(access_token=new_access_token), 200

``` 

Dalam implementasi di atas, saat pengguna berhasil login, sistem akan memberikan **access token** dan **refresh token**. Ketika access token kedaluwarsa, klien dapat menggunakan refresh token untuk mendapatkan access token baru tanpa perlu login ulang.

    1. 2. Penanganan Kesalahan (Error Handling)

Penanganan kesalahan yang tepat penting untuk memberikan informasi yang jelas kepada klien dan meningkatkan keamanan aplikasi. Flask-JWT-Extended menyediakan dekorator untuk menangani berbagai jenis kesalahan terkait JWT.

    • Contoh Penanganan Kesalahan:**


```python from flask_jwt_extended import JWTManager

app.config['JWT_SECRET_KEY'] = 'kunci_rahasia_anda' jwt = JWTManager(app)

@jwt.expired_token_loader def expired_token_callback(jwt_header, jwt_payload): 

   return jsonify({"msg": "Token telah kedaluwarsa"}), 401

@jwt.invalid_token_loader def invalid_token_callback(error): 

   return jsonify({"msg": "Token tidak valid"}), 422

@jwt.unauthorized_loader def missing_token_callback(error): 

   return jsonify({"msg": "Token otorisasi diperlukan"}), 401

``` 

Dengan penanganan kesalahan seperti di atas, aplikasi dapat memberikan respons yang sesuai saat terjadi kesalahan terkait JWT, seperti token kedaluwarsa, tidak valid, atau tidak disertakan dalam permintaan.

    1. 3. Praktik Terbaik dalam Penggunaan JWT

- **Keamanan Kunci Rahasia:** Pastikan kunci rahasia (`JWT_SECRET_KEY`) disimpan dengan aman dan tidak dibagikan. Gunakan variabel lingkungan atau manajer konfigurasi untuk mengelola kunci rahasia.

- **Masa Berlaku Token:** Tetapkan masa berlaku yang sesuai untuk access token dan refresh token. Access token dengan masa berlaku singkat mengurangi risiko jika token dicuri.

- **Penggunaan HTTPS:** Selalu gunakan HTTPS untuk mengenkripsi komunikasi antara klien dan server, sehingga mencegah penyadapan token oleh pihak ketiga.

- **Penyimpanan Token di Klien:** Simpan token dengan aman di sisi klien. Hindari menyimpan token di `localStorage` atau `sessionStorage` karena rentan terhadap serangan XSS. Sebagai alternatif, pertimbangkan untuk menyimpan token di cookie dengan atribut `HttpOnly` dan `Secure`.

- **Penanganan Logout:** Implementasikan mekanisme logout yang efektif dengan mencabut (revoke) token yang telah dikeluarkan. Salah satu caranya adalah dengan menyimpan daftar token yang dicabut di basis data dan memeriksa validitas token pada setiap permintaan.

    • Contoh Implementasi Logout dengan Revokasi Token:**


```python from flask_jwt_extended import get_jwt

  1. Simpan daftar token yang dicabut

revoked_tokens = set()

@app.route('/logout', methods=['DELETE']) @jwt_required() def logout(): 

   jti = get_jwt()['jti']
   revoked_tokens.add(jti)
   return jsonify({"msg": "Logout berhasil"}), 200

@jwt.token_in_blocklist_loader def check_if_token_revoked(jwt_header, jwt_payload): 

   jti = jwt_payload['jti']
   return jti in revoked_tokens

``` 

Dalam contoh di atas, setiap token memiliki **JWT ID (jti)** yang unik. Saat pengguna logout, jti token ditambahkan ke daftar `revoked_tokens`. Pada setiap permintaan yang memerlukan autentikasi, aplikasi memeriksa apakah jti token ada dalam daftar token yang dicabut.

Dengan menerapkan praktik-praktik terbaik di atas, Anda dapat meningkatkan keamanan API yang menggunakan JWT untuk autentikasi dan otorisasi.

    1. 4. Pengujian API dengan Postman

Selain menggunakan cURL, Anda dapat menggunakan **Postman** untuk menguji endpoint yang telah dibuat. Berikut langkah-langkahnya:

1. **Login untuk Mendapatkan Token:** 

  - Buka Postman dan buat permintaan **POST** ke `http://127.0.0.1:5000/login`.
  - Pada tab **Body**, pilih **raw** dan atur tipe menjadi **JSON**.
  - Masukkan data berikut:

    ```json
    {
      "username": "user1",
      "password": "password1"
    }
    ```

  - Klik **Send**. Jika berhasil, Anda akan menerima respons dengan access token dan refresh token.

2. **Mengakses Endpoint yang Dilindungi:** 

  - Buat permintaan **GET** ke `http://127.0.0.1:5000/protected`.
  - Pada tab **Headers**, tambahkan kunci `Authorization` dengan nilai `Bearer <access_token>`, ganti `<access




Melanjutkan pembahasan sebelumnya mengenai pengamanan API dengan JSON Web Token (JWT) dalam aplikasi Flask, kita akan membahas lebih lanjut tentang **implementasi refresh token**, **penanganan logout dengan revokasi token**, dan **praktik terbaik dalam penggunaan JWT**.

    1. 1. Implementasi Refresh Token dalam Flask
    • Refresh token** memungkinkan pengguna untuk mendapatkan access token baru tanpa perlu login kembali setelah access token sebelumnya kedaluwarsa. Hal ini meningkatkan keamanan dan kenyamanan pengguna.
    • Langkah-langkah Implementasi:**

1. **Konfigurasi Masa Berlaku Token:** 

  Tentukan masa berlaku untuk access token dan refresh token dalam konfigurasi aplikasi Flask:

  ```python
  from datetime import timedelta

  app.config['JWT_ACCESS_TOKEN_EXPIRES'] = timedelta(minutes=15)  # Access token berlaku selama 15 menit
  app.config['JWT_REFRESH_TOKEN_EXPIRES'] = timedelta(days=30)    # Refresh token berlaku selama 30 hari
  ```


  Dengan konfigurasi ini, access token memiliki masa berlaku yang singkat, sementara refresh token memiliki masa berlaku yang lebih panjang.

2. **Membuat Endpoint untuk Mendapatkan Refresh Token:** 

  Saat pengguna berhasil login, selain memberikan access token, kita juga memberikan refresh token:

  ```python
  from flask_jwt_extended import create_refresh_token

  @app.route('/login', methods=['POST'])
  def login():
      username = request.json.get('username')
      password = request.json.get('password')
      user = users.get(username)
      if user and check_password_hash(user['password'], password):
          access_token = create_access_token(identity=username, fresh=True)
          refresh_token = create_refresh_token(identity=username)
          return jsonify(access_token=access_token, refresh_token=refresh_token), 200
      return jsonify({"msg": "Username atau password salah"}), 401
  ```


  Dalam kode di atas, `create_refresh_token` digunakan untuk membuat refresh token yang dikirimkan bersama dengan access token setelah proses login berhasil.

3. **Membuat Endpoint untuk Meregenerasi Access Token Menggunakan Refresh Token:** 

  Buat endpoint yang memungkinkan klien untuk mendapatkan access token baru menggunakan refresh token:

  ```python
  from flask_jwt_extended import jwt_required, get_jwt_identity

  @app.route('/refresh', methods=['POST'])
  @jwt_required(refresh=True)
  def refresh():
      current_user = get_jwt_identity()
      new_access_token = create_access_token(identity=current_user, fresh=False)
      return jsonify(access_token=new_access_token), 200
  ```


  Dekorator `@jwt_required(refresh=True)` memastikan bahwa hanya permintaan dengan refresh token yang valid yang dapat mengakses endpoint ini.
    1. 2. Penanganan Logout dengan Revokasi Token

Untuk meningkatkan keamanan, penting untuk memiliki mekanisme logout yang efektif dengan **revokasi token**. Ini memastikan bahwa setelah pengguna logout, token yang sebelumnya diberikan tidak dapat digunakan kembali.

    • Langkah-langkah Implementasi:**

1. **Menyimpan Token yang Dicabut:** 

  Buat struktur data (misalnya, himpunan atau tabel basis data) untuk menyimpan daftar token yang telah dicabut (diblacklist):

  ```python
  from flask_jwt_extended import JWTManager

  app.config['JWT_SECRET_KEY'] = 'kunci_rahasia_anda'
  app.config['JWT_BLACKLIST_ENABLED'] = True
  app.config['JWT_BLACKLIST_TOKEN_CHECKS'] = ['access', 'refresh']
  jwt = JWTManager(app)

  blacklist = set()
  ```


  Konfigurasi `JWT_BLACKLIST_ENABLED` dan `JWT_BLACKLIST_TOKEN_CHECKS` memastikan bahwa aplikasi memeriksa daftar blacklist untuk access token dan refresh token.

2. **Menambahkan Token ke Daftar Blacklist saat Logout:** 

  Buat endpoint logout yang menambahkan token pengguna ke daftar blacklist:

  ```python
  from flask_jwt_extended import get_jwt

  @app.route('/logout', methods=['DELETE'])
  @jwt_required()
  def logout():
      jti = get_jwt()['jti']
      blacklist.add(jti)
      return jsonify({"msg": "Logout berhasil"}), 200
  ```


  Di sini, `get_jwt()['jti']` mengambil JWT ID (jti) dari token saat ini dan menambahkannya ke daftar blacklist.

3. **Memeriksa Apakah Token Telah Dicabut:** 

  Tambahkan fungsi callback untuk memeriksa apakah token termasuk dalam daftar blacklist:

  ```python
  @jwt.token_in_blocklist_loader
  def check_if_token_revoked(jwt_header, jwt_payload):
      jti = jwt_payload['jti']
      return jti in blacklist
  ```


  Dengan implementasi ini, setiap permintaan yang membawa token akan diperiksa apakah token tersebut telah dicabut atau belum.
    1. 3. Praktik Terbaik dalam Penggunaan JWT

- **Keamanan Penyimpanan Token di Klien:** 

 Simpan token dengan aman di sisi klien. Hindari menyimpan token di `localStorage` atau `sessionStorage` karena rentan terhadap serangan XSS. Sebagai alternatif, pertimbangkan untuk menyimpan token di cookie dengan atribut `HttpOnly` dan `Secure`.

 **Contoh Implementasi:**


```python 

 from flask import make_response

 @app.route('/login', methods=['POST'])
 def login():
     # Proses autentikasi
     response = make_response(jsonify({"msg": "Login berhasil"}), 200)
     set_access_cookies(response, access_token)
     set_refresh_cookies(response, refresh_token)
     return response
 ```


 Dalam contoh di atas, `set_access_cookies` dan `set_refresh_cookies` digunakan untuk menyimpan token dalam cookie yang aman.

- **Penggunaan HTTPS:** 

 Selalu gunakan HTTPS untuk mengenkripsi komunikasi antara klien dan server, sehingga mencegah penyadapan token oleh pihak ketiga.

- **Pembaruan Token secara Proaktif:** 

 Perbarui access token sebelum kedaluwarsa untuk memastikan pengalaman pengguna yang lancar. Misalnya, klien 



  - **3.3. Mengamankan API dengan Tokenisasi**
    - Menggunakan token untuk mengamankan komunikasi antara klien dan server.
    - Contoh: Implementasi JSON Web Tokens (JWT) dalam Flask.
    - Referensi: [Membuat REST API dengan Flask](https://www.digitalocean.com/community/tutorials/create-a-rest-api-using-flask-on-ubuntu)
Retrieved from "https://onnocenter.or.id/wiki/index.php?title=Mengamankan_API_dengan_Tokenisasi&oldid=72361"