Halaman ini diterjemahkan oleh Cloud Translation API.

Mengamankan aplikasi Anda dengan header yang ditandatangani

Halaman ini menjelaskan cara mengamankan aplikasi dengan header IAP yang ditandatangani. Saat dikonfigurasi, Identity-Aware Proxy (IAP) menggunakan Token Web JSON (JWT) untuk memastikan bahwa permintaan ke aplikasi Anda diberi otorisasi. Hal ini melindungi aplikasi Anda dari jenis risiko berikut:

IAP dinonaktifkan secara tidak sengaja;
Firewall yang salah dikonfigurasi;
Akses dari dalam project.

Untuk mengamankan aplikasi dengan benar, Anda harus menggunakan header yang ditandatangani untuk semua jenis aplikasi.

Atau, jika Anda memiliki aplikasi lingkungan standar App Engine, Users API dapat digunakan.

Perhatikan bahwa health check Compute Engine dan GKE tidak menyertakan header JWT dan IAP tidak menangani health check. Jika health check menampilkan error akses, pastikan Anda telah mengonfigurasinya dengan benar di konsol Google Cloud dan validasi header JWT Anda mengizinkan jalur health check. Untuk mengetahui informasi selengkapnya, lihat Membuat pengecualian health check.

Sebelum memulai

Untuk mengamankan aplikasi dengan header yang ditandatangani, Anda memerlukan hal berikut:

Aplikasi yang ingin Anda hubungkan dengan pengguna.
Library JWT pihak ketiga untuk bahasa Anda yang mendukung algoritma ES256.

Mengamankan aplikasi Anda dengan header IAP

Untuk mengamankan aplikasi Anda dengan JWT IAP, verifikasi header, payload, dan tanda tangan JWT. JWT berada di header permintaan HTTP x-goog-iap-jwt-assertion. Jika penyerang mengabaikan IAP, mereka dapat memalsukan header identitas IAP yang tidak ditandatangani, x-goog-authenticated-user-{email,id}. JWT IAP menyediakan alternatif yang lebih aman.

Header yang ditandatangani memberikan keamanan sekunder jika seseorang mengabaikan IAP. Perhatikan bahwa saat diaktifkan, IAP akan menghapus header x-goog-* yang disediakan oleh klien saat permintaan melalui infrastruktur penayangan IAP.

Memverifikasi header JWT

Verifikasi bahwa header JWT sesuai dengan batasan berikut:

Klaim Header JWT
`alg`	Algoritme	`ES256`
`kid`	ID Kunci	Harus sesuai dengan salah satu kunci publik yang tercantum dalam file kunci IAP, yang tersedia dalam dua format berbeda: `https://www.gstatic.com/iap/verify/public_key` dan `https://www.gstatic.com/iap/verify/public_key-jwk`

Pastikan JWT ditandatangani oleh kunci pribadi yang sesuai dengan klaim kid token. Untuk melakukannya, ambil kunci publik terlebih dahulu dari salah satu dari dua tempat:

https://www.gstatic.com/iap/verify/public_key. URL ini berisi kamus JSON yang memetakan klaim kid ke nilai kunci publik.
https://www.gstatic.com/iap/verify/public_key-jwk. URL ini berisi kunci publik IAP dalam format JWK.

Setelah Anda memiliki kunci publik, gunakan library JWT untuk memverifikasi tanda tangan.

Memverifikasi payload JWT

Verifikasi bahwa payload JWT sesuai dengan batasan berikut:

Klaim Payload JWT
`exp`	Waktu habis masa berlaku	Harus di masa depan. Waktu diukur dalam hitungan detik sejak epoch UNIX. Tunggu selama 30 detik untuk kemiringan. Masa aktif maksimum token adalah 10 menit + 2 skew.*
`iat`	Waktu penerbitan	Harus di masa lalu. Waktu diukur dalam hitungan detik sejak epoch UNIX. Tunggu selama 30 detik untuk kemiringan.
`aud`	Audiens	Harus berupa string dengan nilai berikut: App Engine: `/projects/PROJECT_NUMBER/apps/PROJECT_ID` Compute Engine dan GKE: `/projects/PROJECT_NUMBER/global/backendServices/SERVICE_ID`
`iss`	Penerbit	Harus berupa `https://cloud.google.com/iap`.
`hd`	Domain akun	Jika akun adalah milik domain yang dihosting, klaim `hd` disediakan untuk membedakan domain yang dikaitkan dengan akun.
`google`	Klaim Google	Jika satu atau beberapa tingkat akses berlaku untuk permintaan, namanya disimpan dalam objek JSON klaim `google`, di bawah kunci `access_levels`, sebagai array string. Saat Anda menentukan kebijakan perangkat dan Organisasi memiliki akses ke data perangkat, `DeviceId` juga disimpan dalam objek JSON. Perhatikan bahwa permintaan yang dikirim ke Organisasi lain mungkin tidak memiliki izin untuk melihat data perangkat.

Anda bisa mendapatkan nilai untuk string aud yang disebutkan di atas dengan mengakses konsol Google Cloud, atau Anda dapat menggunakan alat command line gcloud.

Untuk mendapatkan nilai string aud dari konsol Google Cloud, buka Identity-Aware Proxy settings untuk project Anda, klik More di samping resource Load Balancer, lalu pilih Signed Header JWT Audience. Dialog Signed Header JWT yang muncul akan menampilkan klaim aud untuk resource yang dipilih.

menu tambahan dengan opsi Audiens JWT Header yang Ditandatangani

Jika ingin menggunakan alat command line gcloud gcloud CLI untuk mendapatkan nilai string aud, Anda harus mengetahui project ID. Anda dapat menemukan project ID di kartu Project info Konsol Google Cloud, lalu menjalankan perintah yang ditentukan di bawah untuk setiap nilai.

Nomor project

Untuk mendapatkan nomor project Anda menggunakan alat command line gcloud, jalankan perintah berikut:

gcloud projects describe PROJECT_ID

Perintah ini menampilkan output seperti berikut:

createTime: '2016-10-13T16:44:28.170Z'
lifecycleState: ACTIVE
name: project_name
parent:
  id: '433637338589'
  type: organization
projectId: PROJECT_ID
projectNumber: 'PROJECT_NUMBER'

ID Layanan

Untuk mendapatkan ID layanan menggunakan alat command line gcloud, jalankan perintah berikut:

gcloud compute backend-services describe SERVICE_NAME --project=PROJECT_ID --global

Perintah ini menampilkan output seperti berikut:

affinityCookieTtlSec: 0
backends:
- balancingMode: UTILIZATION
  capacityScaler: 1.0
  group: https://www.googleapis.com/compute/v1/projects/project_name/regions/us-central1/instanceGroups/my-group
connectionDraining:
  drainingTimeoutSec: 0
creationTimestamp: '2017-04-03T14:01:35.687-07:00'
description: ''
enableCDN: false
fingerprint: zaOnO4k56Cw=
healthChecks:
- https://www.googleapis.com/compute/v1/projects/project_name/global/httpsHealthChecks/my-hc
id: 'SERVICE_ID'
kind: compute#backendService
loadBalancingScheme: EXTERNAL
name: my-service
port: 8443
portName: https
protocol: HTTPS
selfLink: https://www.googleapis.com/compute/v1/projects/project_name/global/backendServices/my-service
sessionAffinity: NONE
timeoutSec: 3610

Mengambil identitas pengguna

Jika semua verifikasi di atas berhasil, ambil identitas pengguna. Payload token ID berisi informasi pengguna berikut:

Identitas Pengguna Payload Token ID
`sub`	Subjek	ID unik dan stabil untuk pengguna. Gunakan nilai ini, bukan header `x-goog-authenticated-user-id`.
`email`	Email pengguna	Alamat email pengguna. Gunakan nilai ini, bukan header `x-goog-authenticated-user-email`. Tidak seperti header tersebut dan klaim `sub`, nilai ini tidak memiliki awalan namespace.

Berikut adalah beberapa contoh kode untuk mengamankan aplikasi dengan header IAP yang ditandatangani:

C#


using Google.Apis.Auth;
using Google.Apis.Auth.OAuth2;
using System;
using System.Threading;
using System.Threading.Tasks;

public class IAPTokenVerification
{
    /// <summary>
    /// Verifies a signed jwt token and returns its payload.
    /// </summary>
    /// <param name="signedJwt">The token to verify.</param>
    /// <param name="expectedAudience">The audience that the token should be meant for.
    /// Validation will fail if that's not the case.</param>
    /// <param name="cancellationToken">The cancellation token to propagate cancellation requests.</param>
    /// <returns>A task that when completed will have as its result the payload of the verified token.</returns>
    /// <exception cref="InvalidJwtException">If verification failed. The message of the exception will contain
    /// information as to why the token failed.</exception>
    public async Task<JsonWebSignature.Payload> VerifyTokenAsync(
        string signedJwt, string expectedAudience, CancellationToken cancellationToken = default)
    {
        SignedTokenVerificationOptions options = new SignedTokenVerificationOptions
        {
            // Use clock tolerance to account for possible clock differences
            // between the issuer and the verifier.
            IssuedAtClockTolerance = TimeSpan.FromMinutes(1),
            ExpiryClockTolerance = TimeSpan.FromMinutes(1),
            TrustedAudiences = { expectedAudience },
            TrustedIssuers = { "https://cloud.google.com/iap" },
            CertificatesUrl = GoogleAuthConsts.IapKeySetUrl,
        };

        return await JsonWebSignature.VerifySignedTokenAsync(signedJwt, options, cancellationToken: cancellationToken);
    }
}

Go

import (
	"context"
	"fmt"
	"io"

	"google.golang.org/api/idtoken"
)

// validateJWTFromAppEngine validates a JWT found in the
// "x-goog-iap-jwt-assertion" header.
func validateJWTFromAppEngine(w io.Writer, iapJWT, projectNumber, projectID string) error {
	// iapJWT := "YmFzZQ==.ZW5jb2RlZA==.and0" // req.Header.Get("X-Goog-IAP-JWT-Assertion")
	// projectNumber := "123456789"
	// projectID := "your-project-id"
	ctx := context.Background()
	aud := fmt.Sprintf("/projects/%s/apps/%s", projectNumber, projectID)

	payload, err := idtoken.Validate(ctx, iapJWT, aud)
	if err != nil {
		return fmt.Errorf("idtoken.Validate: %w", err)
	}

	// payload contains the JWT claims for further inspection or validation
	fmt.Fprintf(w, "payload: %v", payload)

	return nil
}

// validateJWTFromComputeEngine validates a JWT found in the
// "x-goog-iap-jwt-assertion" header.
func validateJWTFromComputeEngine(w io.Writer, iapJWT, projectNumber, backendServiceID string) error {
	// iapJWT := "YmFzZQ==.ZW5jb2RlZA==.and0" // req.Header.Get("X-Goog-IAP-JWT-Assertion")
	// projectNumber := "123456789"
	// backendServiceID := "backend-service-id"
	ctx := context.Background()
	aud := fmt.Sprintf("/projects/%s/global/backendServices/%s", projectNumber, backendServiceID)

	payload, err := idtoken.Validate(ctx, iapJWT, aud)
	if err != nil {
		return fmt.Errorf("idtoken.Validate: %w", err)
	}

	// payload contains the JWT claims for further inspection or validation
	fmt.Fprintf(w, "payload: %v", payload)

	return nil
}

Java


import com.google.api.client.http.HttpRequest;
import com.google.api.client.json.webtoken.JsonWebToken;
import com.google.auth.oauth2.TokenVerifier;

/** Verify IAP authorization JWT token in incoming request. */
public class VerifyIapRequestHeader {

  private static final String IAP_ISSUER_URL = "https://cloud.google.com/iap";

  // Verify jwt tokens addressed to IAP protected resources on App Engine.
  // The project *number* for your Google Cloud project via 'gcloud projects describe $PROJECT_ID'
  // The project *number* can also be retrieved from the Project Info card in Cloud Console.
  // projectId is The project *ID* for your Google Cloud Project.
  boolean verifyJwtForAppEngine(HttpRequest request, long projectNumber, String projectId)
      throws Exception {
    // Check for iap jwt header in incoming request
    String jwt = request.getHeaders().getFirstHeaderStringValue("x-goog-iap-jwt-assertion");
    if (jwt == null) {
      return false;
    }
    return verifyJwt(
        jwt,
        String.format("/projects/%s/apps/%s", Long.toUnsignedString(projectNumber), projectId));
  }

  boolean verifyJwtForComputeEngine(HttpRequest request, long projectNumber, long backendServiceId)
      throws Exception {
    // Check for iap jwt header in incoming request
    String jwtToken = request.getHeaders().getFirstHeaderStringValue("x-goog-iap-jwt-assertion");
    if (jwtToken == null) {
      return false;
    }
    return verifyJwt(
        jwtToken,
        String.format(
            "/projects/%s/global/backendServices/%s",
            Long.toUnsignedString(projectNumber), Long.toUnsignedString(backendServiceId)));
  }

  private boolean verifyJwt(String jwtToken, String expectedAudience) {
    TokenVerifier tokenVerifier =
        TokenVerifier.newBuilder().setAudience(expectedAudience).setIssuer(IAP_ISSUER_URL).build();
    try {
      JsonWebToken jsonWebToken = tokenVerifier.verify(jwtToken);

      // Verify that the token contain subject and email claims
      JsonWebToken.Payload payload = jsonWebToken.getPayload();
      return payload.getSubject() != null && payload.get("email") != null;
    } catch (TokenVerifier.VerificationException e) {
      System.out.println(e.getMessage());
      return false;
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const iapJwt = 'SOME_ID_TOKEN'; // JWT from the "x-goog-iap-jwt-assertion" header

let expectedAudience = null;
if (projectNumber && projectId) {
  // Expected Audience for App Engine.
  expectedAudience = `/projects/${projectNumber}/apps/${projectId}`;
} else if (projectNumber && backendServiceId) {
  // Expected Audience for Compute Engine
  expectedAudience = `/projects/${projectNumber}/global/backendServices/${backendServiceId}`;
}

const oAuth2Client = new OAuth2Client();

async function verify() {
  // Verify the id_token, and access the claims.
  const response = await oAuth2Client.getIapPublicKeys();
  const ticket = await oAuth2Client.verifySignedJwtWithCertsAsync(
    iapJwt,
    response.pubkeys,
    expectedAudience,
    ['https://cloud.google.com/iap']
  );
  // Print out the info contained in the IAP ID token
  console.log(ticket);
}

verify().catch(console.error);

PHP

namespace Google\Cloud\Samples\Iap;

# Imports Google auth libraries for IAP validation
use Google\Auth\AccessToken;

/**
 * Validate a JWT passed to your App Engine app by Identity-Aware Proxy.
 *
 * @param string $iapJwt The contents of the X-Goog-IAP-JWT-Assertion header.
 * @param string $cloudProjectNumber The project *number* for your Google
 *     Cloud project. This is returned by 'gcloud projects describe $PROJECT_ID',
 *     or in the Project Info card in Cloud Console.
 * @param string $cloudProjectId Your Google Cloud Project ID.
 */
function validate_jwt_from_app_engine(
    string $iapJwt,
    string $cloudProjectNumber,
    string $cloudProjectId
): void {
    $expectedAudience = sprintf(
        '/projects/%s/apps/%s',
        $cloudProjectNumber,
        $cloudProjectId
    );
    validate_jwt($iapJwt, $expectedAudience);
}

/**
 * Validate a JWT passed to your Compute / Container Engine app by Identity-Aware Proxy.
 *
 * @param string $iapJwt The contents of the X-Goog-IAP-JWT-Assertion header.
 * @param string $cloudProjectNumber The project *number* for your Google
 *     Cloud project. This is returned by 'gcloud projects describe $PROJECT_ID',
 *     or in the Project Info card in Cloud Console.
 * @param string $backendServiceId The ID of the backend service used to access the
 *     application. See https://cloud.google.com/iap/docs/signed-headers-howto
 *     for details on how to get this value.
 */
function validate_jwt_from_compute_engine(
    string $iapJwt,
    string $cloudProjectNumber,
    string $backendServiceId
): void {
    $expectedAudience = sprintf(
        '/projects/%s/global/backendServices/%s',
        $cloudProjectNumber,
        $backendServiceId
    );
    validate_jwt($iapJwt, $expectedAudience);
}

/**
 * Validate a JWT passed to your app by Identity-Aware Proxy.
 *
 * @param string $iapJwt The contents of the X-Goog-IAP-JWT-Assertion header.
 * @param string $expectedAudience The expected audience of the JWT with the following formats:
 *     App Engine:     /projects/{PROJECT_NUMBER}/apps/{PROJECT_ID}
 *     Compute Engine: /projects/{PROJECT_NUMBER}/global/backendServices/{BACKEND_SERVICE_ID}
 */
function validate_jwt(string $iapJwt, string $expectedAudience): void
{
    // Validate the signature using the IAP cert URL.
    $token = new AccessToken();
    $jwt = $token->verify($iapJwt, [
        'certsLocation' => AccessToken::IAP_CERT_URL
    ]);

    if (!$jwt) {
        print('Failed to validate JWT: Invalid JWT');
        return;
    }

    // Validate token by checking issuer and audience fields.
    assert($jwt['iss'] == 'https://cloud.google.com/iap');
    assert($jwt['aud'] == $expectedAudience);

    print('Printing user identity information from ID token payload:');
    printf('sub: %s', $jwt['sub']);
    printf('email: %s', $jwt['email']);
}

Python

from google.auth.transport import requests
from google.oauth2 import id_token


def validate_iap_jwt(iap_jwt, expected_audience):
    """Validate an IAP JWT.

    Args:
      iap_jwt: The contents of the X-Goog-IAP-JWT-Assertion header.
      expected_audience: The Signed Header JWT audience. See
          https://cloud.google.com/iap/docs/signed-headers-howto
          for details on how to get this value.

    Returns:
      (user_id, user_email, error_str).
    """

    try:
        decoded_jwt = id_token.verify_token(
            iap_jwt,
            requests.Request(),
            audience=expected_audience,
            certs_url="https://www.gstatic.com/iap/verify/public_key",
        )
        return (decoded_jwt["sub"], decoded_jwt["email"], "")
    except Exception as e:
        return (None, None, f"**ERROR: JWT validation error {e}**")

Ruby

# iap_jwt = "The contents of the X-Goog-Iap-Jwt-Assertion header"
# project_number = "The project *number* for your Google Cloud project"
# project_id = "Your Google Cloud project ID"
# backend_service_id = "Your Compute Engine backend service ID"
require "googleauth"

audience = nil
if project_number && project_id
  # Expected audience for App Engine
  audience = "/projects/#{project_number}/apps/#{project_id}"
elsif project_number && backend_service_id
  # Expected audience for Compute Engine
  audience = "/projects/#{project_number}/global/backendServices/#{backend_service_id}"
end

# The client ID as the target audience for IAP
payload = Google::Auth::IDTokens.verify_iap iap_jwt, aud: audience

puts payload

if audience.nil?
  puts "Audience not verified! Supply a project_number and project_id to verify"
end

Menguji kode validasi

Jika Anda mengunjungi aplikasi menggunakan parameter kueri secure_token_test, IAP akan menyertakan JWT yang tidak valid. Gunakan ini untuk memastikan logika validasi JWT Anda menangani semua kasus kegagalan, dan untuk melihat perilaku aplikasi Anda saat menerima JWT yang tidak valid.

Membuat pengecualian health check

Seperti yang disebutkan sebelumnya, health check Compute Engine dan GKE tidak menggunakan header JWT dan IAP tidak menangani health check. Anda harus mengonfigurasi health check dan aplikasi untuk mengizinkan akses health check.

Mengonfigurasi health check

Jika Anda belum menetapkan jalur untuk health check, gunakan konsol Google Cloud untuk menetapkan jalur non-sensitif untuk health check. Pastikan jalur ini tidak digunakan bersama oleh resource lain.

Buka halaman Health checks di konsol Google Cloud.
Buka halaman Health checks
Klik pemeriksaan kesehatan yang Anda gunakan untuk aplikasi, lalu klik Edit.
Di bagian Jalur permintaan, tambahkan nama jalur yang tidak sensitif. Ini menentukan jalur URL yang digunakan Google Cloud saat mengirim permintaan pemeriksaan kesehatan. Jika dihilangkan, permintaan health check akan dikirim ke /.
Klik Simpan.

Mengonfigurasi validasi JWT

Dalam kode yang memanggil rutinitas validasi JWT, tambahkan kondisi untuk menampilkan status HTTP 200 untuk jalur permintaan health check Anda. Contoh:

if HttpRequest.path_info = '/HEALTH_CHECK_REQUEST_PATH'
  return HttpResponse(status=200)
else
  VALIDATION_FUNCTION

JWT untuk identitas eksternal

Jika Anda menggunakan IAP dengan identitas eksternal, IAP akan tetap menerbitkan JWT yang ditandatangani pada setiap permintaan yang diautentikasi, seperti halnya dengan identitas Google. Namun, ada beberapa perbedaan.

Informasi penyedia

Saat menggunakan identitas eksternal, payload JWT akan berisi klaim bernama gcip. Klaim ini berisi informasi tentang pengguna, seperti URL email dan foto, serta atribut khusus penyedia tambahan.

Berikut adalah contoh JWT untuk pengguna yang login dengan Facebook:

"gcip": '{
  "auth_time": 1553219869,
  "email": "facebook_user@gmail.com",
  "email_verified": false,
  "firebase": {
    "identities": {
      "email": [
        "facebook_user@gmail.com"
      ],
      "facebook.com": [
        "1234567890"
      ]
    },
    "sign_in_provider": "facebook.com",
  },
  "name": "Facebook User",
  "picture: "https://graph.facebook.com/1234567890/picture",
  "sub": "gZG0yELPypZElTmAT9I55prjHg63"
}',

Kolom `email` dan `sub`

Jika pengguna diautentikasi oleh Identity Platform, kolom email dan sub JWT akan diawali dengan penerbit token Identity Platform dan ID tenant yang digunakan (jika ada). Contoh:

"email": "securetoken.google.com/PROJECT-ID/TENANT-ID:demo_user@gmail.com",
"sub": "securetoken.google.com/PROJECT-ID/TENANT-ID:gZG0yELPypZElTmAT9I55prjHg63"

Mengontrol akses dengan `sign_in_attributes`

IAM tidak didukung untuk digunakan dengan identitas eksternal, tetapi Anda dapat menggunakan klaim yang disematkan di kolom sign_in_attributes untuk mengontrol akses. Misalnya, pertimbangkan pengguna yang login menggunakan penyedia SAML:

{
  "aud": "/projects/project_number/apps/my_project_id",
  "gcip": '{
    "auth_time": 1553219869,
    "email": "demo_user@gmail.com",
    "email_verified": true,
    "firebase": {
      "identities": {
        "email": [
          "demo_user@gmail.com"
        ],
        "saml.myProvider": [
          "demo_user@gmail.com"
        ]
      },
      "sign_in_attributes": {
        "firstname": "John",
        "group": "test group",
        "role": "admin",
        "lastname": "Doe"
      },
      "sign_in_provider": "saml.myProvider",
      "tenant": "my_tenant_id"
    },
    "sub": "gZG0yELPypZElTmAT9I55prjHg63"
  }',
  "email": "securetoken.google.com/my_project_id/my_tenant_id:demo_user@gmail.com",
  "exp": 1553220470,
  "iat": 1553219870,
  "iss": "https://cloud.google.com/iap",
  "sub": "securetoken.google.com/my_project_id/my_tenant_id:gZG0yELPypZElTmAT9I55prjHg63"
}

Anda dapat menambahkan logika ke aplikasi yang mirip dengan kode di bawah untuk membatasi akses ke pengguna dengan peran yang valid:

const gcipClaims = JSON.parse(decodedIapJwtClaims.gcip);
if (gcipClaims &&
    gcipClaims.firebase &&
    gcipClaims.firebase.sign_in_attributes &&
    gcipClaims.firebase.sign_in_attribute.role === 'admin') {
  // Allow access to admin restricted resource.
} else {
  // Block access.
}

Atribut pengguna tambahan dari penyedia SAML dan OIDC Identity Platform dapat diakses menggunakan klaim bertingkat gcipClaims.gcip.firebase.sign_in_attributes.

Batasan ukuran klaim IdP

Setelah pengguna login dengan Identity Platform, atribut pengguna tambahan akan disebarkan ke payload token ID Identity Platform stateless yang akan diteruskan dengan aman ke IAP. IAP kemudian akan menerbitkan cookie buram stateless-nya sendiri yang juga berisi klaim yang sama. IAP akan membuat header JWT yang ditandatangani berdasarkan konten cookie.

Akibatnya, jika sesi dimulai dengan klaim dalam jumlah besar, sesi tersebut mungkin melebihi ukuran cookie maksimum yang diizinkan, yang biasanya ~4 KB di sebagian besar browser. Hal ini akan menyebabkan operasi login gagal.

Anda harus memastikan bahwa hanya klaim yang diperlukan yang disebarkan di atribut OIDC atau SAML IdP. Opsi lainnya adalah menggunakan fungsi pemblokiran untuk memfilter klaim yang tidak diperlukan untuk pemeriksaan otorisasi.

const gcipCloudFunctions = require('gcip-cloud-functions');

const authFunctions = new gcipCloudFunctions.Auth().functions();

// This function runs before any sign-in operation.
exports.beforeSignIn = authFunctions.beforeSignInHandler((user, context) => {
  if (context.credential &&
      context.credential.providerId === 'saml.my-provider') {
    // Get the original claims.
    const claims = context.credential.claims;
    // Define this function to filter out the unnecessary claims.
    claims.groups = keepNeededClaims(claims.groups);
    // Return only the needed claims. The claims will be propagated to the token
    // payload.
    return {
      sessionClaims: claims,
    };
  }
});