Menggunakan cookie bertanda tangan

Halaman ini berisi ringkasan tentang cookie bertanda tangan dan petunjuk untuk menggunakannya dengan Cloud CDN. Cookie bertanda tangan memberikan akses resource dalam waktu terbatas ke sekumpulan file, terlepas dari apakah pengguna memiliki Akun Google atau tidak.

Cookie bertanda tangan adalah alternatif dari URL bertanda tangan. Cookie bertanda tangan melindungi akses saat penandatanganan puluhan atau ratusan URL secara terpisah untuk setiap pengguna di aplikasi Anda tidak mungkin dilakukan.

Cookie bertanda tangan memungkinkan Anda melakukan hal-hal berikut:

• Memberi pengguna izin dan token berbatas waktu untuk mengakses konten yang Anda lindungi (alih-alih menandatangani setiap URL).
• Membatasi cakupan akses pengguna ke awalan URL tertentu, misalnya https://media.example.com/videos/, dan memberi pengguna yang diizinkan akses ke konten yang dilindungi dalam awalan URL itu saja.
• Mempertahankan URL dan manifes media, sehingga menyederhanakan pipeline pemaketan dan meningkatkan cacheability.

Jika Anda ingin membatasi akses ke URL tertentu, pertimbangkan untuk menggunakan URL bertanda tangan.

Sebelum memulai

Sebelum Anda menggunakan cookie bertanda tangan, lakukan hal-hal berikut:

• Pastikan Cloud CDN diaktifkan. Untuk mengetahui petunjuknya, baca bagian Menggunakan Cloud CDN. Anda dapat mengonfigurasi cookie bertanda tangan di backend sebelum mengaktifkan Cloud CDN, tetapi tidak akan ada efeknya hingga Cloud CDN diaktifkan.

• Jika perlu, update ke Google Cloud CLI versi terbaru:

  gcloud components update
  

Untuk mengetahui ringkasannya, baca bagian URL bertanda tangan dan cookie bertanda tangan.

Mengonfigurasi kunci permintaan bertanda tangan

Pembuatan kunci untuk URL bertanda tangan atau cookie bertanda tangan memerlukan beberapa langkah, yang dijelaskan di bagian berikut.

Pertimbangan keamanan

Penting: Anda harus mengonfigurasi server web asal untuk memvalidasi tanda tangan pada setiap permintaan bertanda tangan yang disajikan, dan menerima atau menolak permintaan yang tidak bertanda tangan.

Cloud CDN tidak akan memvalidasi permintaan dalam situasi berikut:

• Permintaan tidak bertanda tangan.
• Layanan backend atau bucket backend untuk permintaan tidak mengaktifkan Cloud CDN.

Permintaan bertanda tangan harus selalu divalidasi di server asal sebelum menyajikan respons. Hal ini karena server asal dapat digunakan untuk menyajikan kombinasi konten bertanda tangan dan tidak bertanda tangan, dan karena klien dapat mengakses server asal secara langsung.

• Cloud CDN tidak akan memblokir permintaan tanpa parameter kueri Signature atau cookie HTTP Cloud-CDN-Cookie. Cloud CDN akan menolak permintaan dengan parameter permintaan yang tidak valid (atau salah format).
• Saat mendeteksi tanda tangan yang tidak valid, pastikan aplikasi Anda merespons dengan kode respons HTTP 403 (Unauthorized). Kode respons HTTP 403 tidak dapat di-cache.
• Respons terhadap permintaan bertanda tangan dan tidak bertanda tangan akan di-cache terpisah, sehingga respons yang berhasil terhadap permintaan bertanda tangan yang valid tidak akan pernah digunakan untuk menyajikan permintaan yang tidak bertanda tangan.
• Jika aplikasi Anda mengirimkan kode respons yang dapat di-cache ke permintaan yang tidak valid, permintaan valid berikutnya mungkin akan ditolak secara keliru.

Untuk backend Cloud Storage, pastikan untuk menghapus akses publik, sehingga Cloud Storage dapat menolak permintaan yang tidak memiliki tanda tangan valid.

Tabel berikut merangkum perilaku.

Permintaan memiliki tanda tangan	Cache ditemukan	Perilaku
Tidak	Tidak	Meneruskan ke server asal backend.
Tidak	Ya	Menyajikan dari cache.
Ya	Tidak	Memvalidasi tanda tangan. Jika valid, meneruskan ke server asal backend.
Ya	Ya	Memvalidasi tanda tangan. Jika valid, menyajikan dari cache.

Membuat kunci permintaan bertanda tangan

Guna mengaktifkan dukungan untuk URL bertanda tangan dan cookie bertanda tangan Cloud CDN, Anda harus membuat satu atau beberapa kunci di layanan backend yang mengaktifkan Cloud CDN, bucket backend yang mengaktifkan Cloud CDN, atau keduanya.

Untuk setiap layanan backend atau bucket backend, Anda dapat membuat dan menghapus kunci sesuai kebutuhan keamanan Anda. Setiap backend dapat memiliki hingga tiga kunci yang dikonfigurasi sekaligus. Sebaiknya Anda merotasi kunci secara berkala dengan menghapus kunci terlama, lalu menambahkan kunci baru, dan menggunakan kunci baru tersebut saat menandatangani URL atau cookie.

Anda dapat menggunakan nama kunci yang sama di beberapa layanan backend dan bucket backend karena setiap set kunci bersifat independen. Nama kunci terdiri atas maksimal 63 karakter. Untuk memberi nama kunci, gunakan karakter A-Z, a-z, 0-9, _ (garis bawah), dan - (tanda hubung).

Saat membuat kunci, pastikan untuk menjaga keamanannya karena siapa pun yang memiliki salah satu kunci Anda akan dapat membuat URL atau cookie bertanda tangan yang diterima Cloud CDN hingga kunci tersebut dihapus dari Cloud CDN. Kunci akan disimpan di komputer tempat Anda menghasilkan URL bertanda tangan atau cookie bertanda tangan. Cloud CDN juga menyimpan kunci tersebut untuk memverifikasi tanda tangan permintaan.

Untuk menjaga kerahasiaan kunci, nilai kunci tidak akan disertakan dalam respons terhadap permintaan API apa pun. Jika Anda kehilangan kunci, Anda harus membuat kunci baru.

Penting: Jaga kerahasiaan file kunci yang dihasilkan, dan jangan mengeksposnya kepada pengguna atau menyimpannya langsung dalam kode sumber. Pertimbangkan untuk menggunakan mekanisme penyimpanan rahasia seperti Cloud Key Management Service untuk mengenkripsi kunci dan berikan akses hanya ke aplikasi tepercaya.

Untuk membuat kunci permintaan bertanda tangan, ikuti langkah-langkah berikut.

Konsol

1. Di Konsol Google Cloud , buka halaman Cloud CDN.

   Buka Cloud CDN

2. Klik nama server asal tempat Anda ingin menambahkan kunci.
3. Di halaman Origin details, klik tombol Edit.
4. Di bagian Origin basics, klik Next untuk membuka bagian Host and path rules.
5. Di bagian Host and path rules, klik Next untuk membuka bagian Cache performance.
6. Di bagian Restricted content, pilih Restrict access using signed URLs and signed cookies.

7. Klik Add signing key.

   1. Tentukan nama unik untuk kunci penandatanganan baru Anda.

   2. Di bagian Key creation method, pilih Automatically generate. Atau, klik Let me enter, lalu tentukan nilai kunci penandatanganan.

      Untuk opsi pertama, salin nilai kunci penandatanganan yang dihasilkan secara otomatis ke file pribadi, yang dapat Anda gunakan untuk membuat URL bertanda tangan.

   3. Klik Done.

   4. Di bagian Cache entry maximum age, masukkan nilai, lalu pilih satuan waktu.

8. Klik Done.

gcloud

Alat command line gcloud dapat membaca kunci dari file lokal yang Anda tentukan. File kunci harus dibuat dengan menghasilkan 128 bit sangat acak, mengenkode bit tersebut dengan base64, lalu mengganti karakter + dengan - dan karakter / dengan _. Untuk mengetahui informasi selengkapnya, lihat RFC 7300. Kunci harus sangat acak. Pada sistem yang mirip UNIX, Anda dapat menghasilkan kunci yang sangat acak dan menyimpannya dalam file kunci dengan perintah berikut:

head -c 16 /dev/urandom | base64 | tr +/ -_ > KEY_FILE_NAME

Untuk menambahkan kunci ke layanan backend:

gcloud compute backend-services \
   add-signed-url-key BACKEND_NAME \
   --key-name KEY_NAME \
   --key-file KEY_FILE_NAME

Untuk menambahkan kunci ke bucket backend:

gcloud compute backend-buckets \
   add-signed-url-key BACKEND_NAME \
   --key-name KEY_NAME \
   --key-file KEY_FILE_NAME

Catatan: Meskipun sub-perintahnya adalah add-signed-url-key, kunci ini adalah kunci permintaan bertanda tangan yang dapat digunakan baik untuk cookie bertanda tangan maupun URL bertanda tangan.

Mengonfigurasi izin Cloud Storage

Jika Anda menggunakan Cloud Storage dan telah membatasi siapa yang dapat membaca objek, Anda harus memberi Cloud CDN izin untuk membaca objek tersebut dengan menambahkan akun layanan Cloud CDN ke ACL Cloud Storage.

Anda tidak perlu membuat akun layanan. Akun layanan dibuat otomatis saat Anda pertama kali menambahkan kunci ke bucket backend dalam sebuah project.

Sebelum menjalankan perintah berikut, tambahkan minimal satu kunci ke bucket backend dalam project Anda. Jika tidak, perintah akan gagal disertai error karena akun layanan pengisian cache Cloud CDN tidak akan dibuat sampai Anda menambahkan satu atau beberapa kunci untuk project tersebut.

Catatan: Jika Anda memiliki kebijakan organisasi domain restricted sharing (DRS) dalam project itu, Anda harus menonaktifkannya sebelum menjalankan perintah gcloud storage buckets add-iam-policy-binding. Pastikan untuk mengaktifkan kembali kebijakan tersebut setelah menjalankan perintah gcloud storage buckets add-iam-policy-binding.

gcloud storage buckets add-iam-policy-binding gs://BUCKET \
  --member=serviceAccount:[e-mail] \
  --role=roles/storage.objectViewer

Ganti PROJECT_NUMBER dengan nomor project Anda dan BUCKET dengan bucket penyimpanan Anda.

Akun layanan Cloud CDN [e-mail] tidak akan muncul dalam daftar akun layanan dalam project Anda. Hal ini karena akun layanan Cloud CDN dimiliki oleh Cloud CDN, bukan oleh project Anda.

Untuk mengetahui informasi selengkapnya tentang nomor project, baca bagian Menemukan project ID dan nomor project dalam dokumentasi Bantuan Konsol Google Cloud .

Menyesuaikan waktu cache maksimum

Cloud CDN meng-cache respons untuk permintaan bertanda tangan, terlepas dari header Cache-Control backend. Waktu maksimum respons dapat di-cache tanpa validasi ulang ditetapkan oleh flag signed-url-cache-max-age, yang secara default adalah satu jam dan dapat diubah seperti yang ditunjukkan di sini.

Untuk menetapkan waktu cache maksimum untuk layanan backend atau bucket backend, jalankan salah satu perintah berikut:

gcloud compute backend-services update BACKEND_NAME \
  --signed-url-cache-max-age MAX_AGE

gcloud compute backend-buckets update BACKEND_NAME \
  --signed-url-cache-max-age MAX_AGE

Menampilkan daftar nama kunci permintaan bertanda tangan

Untuk menampilkan daftar kunci di layanan backend atau bucket backend, jalankan salah satu perintah berikut:

gcloud compute backend-services describe BACKEND_NAME

gcloud compute backend-buckets describe BACKEND_NAME

Menghapus kunci permintaan bertanda tangan

Jika URL yang ditandatangani dengan kunci tertentu tidak akan digunakan lagi, jalankan salah satu perintah berikut untuk menghapus kunci tersebut dari layanan backend atau bucket backend:

gcloud compute backend-services \
   delete-signed-url-key BACKEND_NAME --key-name KEY_NAME

gcloud compute backend-buckets \
   delete-signed-url-key BACKEND_NAME --key-name KEY_NAME

Membuat kebijakan

Kebijakan cookie bertanda tangan adalah serangkaian pasangan key-value (dibatasi oleh karakter :), yang mirip dengan parameter kueri yang digunakan dalam URL bertanda tangan. Untuk melihat contoh, baca bagian Menyediakan cookie kepada pengguna.

Kebijakan mewakili parameter yang membuat permintaan menjadi valid. Kebijakan ditandatangani menggunakan hash-based message authentication code (HMAC) yang divalidasi Cloud CDN pada setiap permintaan.

Menentukan format dan kolom kebijakan

Ada empat kolom wajib diisi yang harus Anda tentukan dalam urutan berikut:

• URLPrefix
• Expires
• KeyName
• Signature

Pasangan key-value dalam kebijakan cookie bertanda tangan bersifat peka huruf besar/kecil.

URLPrefix

URLPrefix menunjukkan awalan URL berenkode base64 yang aman untuk URL dan mencakup semua jalur yang akan valid untuk tanda tangan tersebut.

URLPrefix mengenkode skema (entah http:// atau https://), FQDN, dan jalur opsional. Mengakhiri jalur dengan / bersifat opsional, tetapi direkomendasikan. Awalan tidak boleh menyertakan parameter kueri atau fragmen seperti ? atau #.

Misalnya, https://media.example.com/videos cocok dengan permintaan ke kedua URL berikut:

• https://media.example.com/videos?video_id=138183&user_id=138138
• https://media.example.com/videos/137138595?quality=low

Jalur awalan digunakan sebagai substring teks, bukan jalur direktori. Misalnya, awalan https://example.com/data akan memberikan akses ke kedua hal berikut:

• /data/file1
• /database

Untuk menghindari kesalahan ini, sebaiknya akhiri semua awalan dengan /, kecuali jika Anda sengaja memilih untuk mengakhiri awalan dengan nama file parsial seperti https://media.example.com/videos/123 untuk memberikan akses ke hal-hal berikut:

• /videos/123_chunk1
• /videos/123_chunk2
• /videos/123_chunkN

Jika URL yang diminta tidak cocok dengan URLPrefix, Cloud CDN akan menolak permintaan itu dan menampilkan error HTTP 403 kepada klien.

Expires

Expires harus berupa stempel waktu Unix (jumlah detik sejak 1 Januari 1970).

KeyName

KeyName adalah nama kunci untuk kunci yang dibuat terhadap bucket backend atau layanan backend. Nama kunci peka huruf besar/kecil.

Signature

Signature adalah tanda tangan HMAC-SHA-1 berenkode base64 yang aman untuk URL dari kolom yang membentuk kebijakan cookie. Tanda tangan ini divalidasi pada setiap permintaan. Permintaan dengan tanda tangan yang tidak valid akan ditolak dengan error HTTP 403.

Membuat cookie bertanda tangan secara terprogram

Contoh kode berikut menunjukkan cara membuat cookie bertanda tangan secara terprogram.

Catatan: Sebaiknya gunakan Secret Manager untuk mengelola akses ke kunci penandatanganan Anda.

Catatan: Komponen host dan jalur URLPrefix digunakan untuk memvalidasi tanda tangan. Saat Anda memberikan URLPrefix ke API terprogram, hapus port-nya. Dengan kata lain, untuk jalur seperti https://example.com:443/path/, tentukan jalur tersebut sebagai https://example.com/path/. Jika tidak, tanda tangan yang dihasilkan tidak akan cocok dengan nilai yang dikomputasi Cloud CDN.

Go

import (
	"crypto/hmac"
	"crypto/sha1"
	"encoding/base64"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	"time"
)

// signCookie creates a signed cookie for an endpoint served by Cloud CDN.
//
// - urlPrefix must start with "https://" and should include the path prefix
// for which the cookie will authorize access to.
// - key should be in raw form (not base64url-encoded) which is
// 16-bytes long.
// - keyName must match a key added to the backend service or bucket.
func signCookie(urlPrefix, keyName string, key []byte, expiration time.Time) (string, error) {
	encodedURLPrefix := base64.URLEncoding.EncodeToString([]byte(urlPrefix))
	input := fmt.Sprintf("URLPrefix=%s:Expires=%d:KeyName=%s",
		encodedURLPrefix, expiration.Unix(), keyName)

	mac := hmac.New(sha1.New, key)
	mac.Write([]byte(input))
	sig := base64.URLEncoding.EncodeToString(mac.Sum(nil))

	signedValue := fmt.Sprintf("%s:Signature=%s",
		input,
		sig,
	)

	return signedValue, nil
}

Java

import java.net.MalformedURLException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.time.ZonedDateTime;
import java.util.Base64;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class SignedCookies {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.

    // The name of the signing key must match a key added to the back end bucket or service.
    String keyName = "YOUR-KEY-NAME";
    // Path to the URL signing key uploaded to the backend service/bucket.
    String keyPath = "/path/to/key";
    // The Unix timestamp that the signed URL expires.
    long expirationTime = ZonedDateTime.now().plusDays(1).toEpochSecond();
    // URL prefix to sign as a string. URL prefix must start with either "http://" or "https://"
    // and must not include query parameters.
    String urlPrefix = "https://media.example.com/videos/";

    // Read the key as a base64 url-safe encoded string, then convert to byte array.
    // Key used in signing must be in raw form (not base64url-encoded).
    String base64String = new String(Files.readAllBytes(Paths.get(keyPath)),
        StandardCharsets.UTF_8);
    byte[] keyBytes = Base64.getUrlDecoder().decode(base64String);

    // Create signed cookie from policy.
    String signedCookie = signCookie(urlPrefix, keyBytes, keyName, expirationTime);
    System.out.println(signedCookie);
  }

  // Creates a signed cookie for the specified policy.
  public static String signCookie(String urlPrefix, byte[] key, String keyName,
      long expirationTime)
      throws InvalidKeyException, NoSuchAlgorithmException {

    // Validate input URL prefix.
    try {
      URL validatedUrlPrefix = new URL(urlPrefix);
      if (!validatedUrlPrefix.getProtocol().startsWith("http")) {
        throw new IllegalArgumentException(
            "urlPrefix must start with either http:// or https://: " + urlPrefix);
      }
      if (validatedUrlPrefix.getQuery() != null) {
        throw new IllegalArgumentException("urlPrefix must not include query params: " + urlPrefix);
      }
    } catch (MalformedURLException e) {
      throw new IllegalArgumentException(
          "urlPrefix malformed: " + urlPrefix);
    }

    String encodedUrlPrefix = Base64.getUrlEncoder().encodeToString(urlPrefix.getBytes(
        StandardCharsets.UTF_8));
    String policyToSign = String.format("URLPrefix=%s:Expires=%d:KeyName=%s", encodedUrlPrefix,
        expirationTime, keyName);

    String signature = getSignatureForUrl(key, policyToSign);
    return String.format("Cloud-CDN-Cookie=%s:Signature=%s", policyToSign, signature);
  }

  // Creates signature for input string with private key.
  private static String getSignatureForUrl(byte[] privateKey, String input)
      throws InvalidKeyException, NoSuchAlgorithmException {

    final String algorithm = "HmacSHA1";
    final int offset = 0;
    Key key = new SecretKeySpec(privateKey, offset, privateKey.length, algorithm);
    Mac mac = Mac.getInstance(algorithm);
    mac.init(key);
    return Base64.getUrlEncoder()
        .encodeToString(mac.doFinal(input.getBytes(StandardCharsets.UTF_8)));
  }
}

Python

import argparse
import base64
from datetime import datetime, timezone
import hashlib
import hmac
from urllib.parse import parse_qs, urlsplit


def sign_cookie(
    url_prefix: str,
    key_name: str,
    base64_key: str,
    expiration_time: datetime,
) -> str:
    """Gets the Signed cookie value for the specified URL prefix and configuration.

    Args:
        url_prefix: URL prefix to sign.
        key_name: name of the signing key.
        base64_key: signing key as a base64 encoded string.
        expiration_time: expiration time as time-zone aware datetime.

    Returns:
        Returns the Cloud-CDN-Cookie value based on the specified configuration.
    """
    encoded_url_prefix = base64.urlsafe_b64encode(
        url_prefix.strip().encode("utf-8")
    ).decode("utf-8")
    epoch = datetime.fromtimestamp(0, timezone.utc)
    expiration_timestamp = int((expiration_time - epoch).total_seconds())
    decoded_key = base64.urlsafe_b64decode(base64_key)

    policy = f"URLPrefix={encoded_url_prefix}:Expires={expiration_timestamp}:KeyName={key_name}"

    digest = hmac.new(decoded_key, policy.encode("utf-8"), hashlib.sha1).digest()
    signature = base64.urlsafe_b64encode(digest).decode("utf-8")

    signed_policy = f"Cloud-CDN-Cookie={policy}:Signature={signature}"

    return signed_policy

Memvalidasi cookie bertanda tangan

Proses memvalidasi cookie bertanda tangan pada dasarnya sama dengan proses menghasilkan cookie bertanda tangan. Misalkan Anda ingin memvalidasi header cookie bertanda tangan berikut:

Cookie: Cloud-CDN-Cookie=URLPrefix=URL_PREFIX:Expires=EXPIRATION:KeyName=KEY_NAME:Signature=SIGNATURE; Domain=media.example.com; Path=/; Expires=Tue, 20 Aug 2019 02:26:49 GMT; HttpOnly

Anda dapat menggunakan kunci rahasia yang dinamai oleh KEY_NAME untuk menghasilkan tanda tangan secara independen, lalu memvalidasi bahwa tanda tangan tersebut cocok dengan SIGNATURE.

Menerbitkan cookie untuk pengguna

Aplikasi Anda harus menghasilkan dan menerbitkan satu cookie HTTP yang berisi kebijakan yang ditandatangani dengan benar untuk setiap pengguna (klien):

1. Buat penanda tangan HMAC-SHA-1 dalam kode aplikasi Anda.

2. Tanda tangani kebijakan menggunakan kunci yang dipilih, dengan mencatat nama kunci yang Anda tambahkan ke backend, misalnya mySigningKey.

3. Buat kebijakan cookie dengan format berikut, dengan memperhatikan bahwa nama dan nilai tersebut bersifat peka huruf besar/kecil:

   Name: Cloud-CDN-Cookie
   Value: URLPrefix=$BASE64URLECNODEDURLORPREFIX:Expires=$TIMESTAMP:KeyName=$KEYNAME:Signature=$BASE64URLENCODEDHMAC
   

   Contoh header Set-Cookie:

   Set-Cookie: Cloud-CDN-Cookie=URLPrefix=aHR0cHM6Ly9tZWRpYS5leGFtcGxlLmNvbS92aWRlb3Mv:Expires=1566268009:KeyName=mySigningKey:Signature=0W2xlMlQykL2TG59UZnnHzkxoaw=; Domain=media.example.com; Path=/; Expires=Tue, 20 Aug 2019 02:26:49 GMT; HttpOnly
   

   Atribut Domain dan Path dalam cookie menentukan apakah klien mengirim cookie ke Cloud CDN atau tidak.

Rekomendasi dan persyaratan

• Tetapkan atribut Domain dan Path secara eksplisit agar cocok dengan awalan domain dan jalur tempat Anda ingin menyajikan konten yang dilindungi, yang mungkin berbeda dengan domain dan jalur tempat cookie diterbitkan (example.com versus media.example.com atau /browse versus /videos).

• Pastikan Anda hanya memiliki satu cookie dengan nama tertentu untuk Domain dan Path yang sama.

• Pastikan Anda tidak menerbitkan cookie yang bertentangan karena hal ini dapat mencegah akses ke konten dalam sesi browser lain (jendela atau tab).

• Tetapkan flag Secure dan HttpOnly jika berlaku. Secure memastikan bahwa cookie hanya dikirim melalui koneksi HTTPS. HttpOnly mencegah cookie disediakan untuk JavaScript.

• Atribut cookie Expires dan Max-Age bersifat opsional. Jika Anda menghapusnya, cookie akan ada selama sesi browser (tab, jendela) ada.

  Catatan: Atribut Expires yang disebutkan di sini adalah atribut yang (jika ada) akan muncul di luar nilai cookie. Jangan keliru menganggap atribut ini sebagai parameter Expires yang ada dalam nilai cookie, yang wajib diisi. Parameter Expires yang ada dalam nilai cookie menentukan batas waktu kapan Cloud CDN mengizinkan pengguna mengakses konten yang dilindungi. Batas waktu ini tidak bergantung pada masa aktif cookie.

• Jika terjadi pengisian cache atau cache tidak ditemukan, cookie bertanda tangan akan diteruskan ke server asal yang ditetapkan di layanan backend. Pastikan Anda memvalidasi nilai cookie bertanda tangan pada setiap permintaan sebelum menyajikan konten.