Questa pagina è stata tradotta dall'API Cloud Translation.

Protezione dell'app con intestazioni firmate

Questa pagina descrive come proteggere la tua app con intestazioni IAP firmate. Se configurato, Identity-Aware Proxy (IAP) utilizza JSON token web (JWT) per garantire che una richiesta alla tua app venga autorizzati. In questo modo protegge la tua app dai seguenti tipi di rischi:

IAP è stato disattivato accidentalmente.
Firewall configurati in modo errato.
Accesso dall'interno del progetto.

Per proteggere correttamente la tua app, devi utilizzare intestazioni firmate per tutti i tipi di app.

In alternativa, se hai un'app dell'ambiente standard di App Engine, È possibile utilizzare l'API Users.

Tieni presente che i controlli di integrità di Compute Engine e GKE non includono le intestazioni JWT e che IAP non gestisce i controlli di integrità. Se il controllo di integrità restituisce errori di accesso, assicurati di averlo configurato correttamente nella console Google Cloud e che l'intestazione JWT di controllo di integrità consente il percorso del controllo di integrità. Per ulteriori informazioni, vedi Crea un controllo di integrità del prodotto.

Prima di iniziare

Per proteggere la tua app con intestazioni firmate, ti occorre quanto segue:

Un'applicazione a cui vuoi che gli utenti si connettano.
Una libreria JWT di terze parti per la tua lingua che supporti l'algoritmo ES256.

Protezione dell'app con le intestazioni IAP

Per proteggere l'app con il JWT di IAP, verifica l'intestazione, e firma del JWT. Il JWT si trova nell'intestazione della richiesta HTTP x-goog-iap-jwt-assertion. Se un aggressore aggira IAP, possono falsificare le intestazioni di identità non firmate IAP, x-goog-authenticated-user-{email,id}. Il token JWT IAP offre un'alternativa più sicura.

Le intestazioni firmate forniscono una sicurezza secondaria nel caso in cui qualcuno aggiri IAP. Tieni presente che quando IAP è attivato, rimuove le intestazioni x-goog-* fornite dal client quando la richiesta va attraverso l'infrastruttura di gestione IAP.

Verifica dell'intestazione JWT

Verifica che l'intestazione JWT sia conforme ai seguenti vincoli:

Claim dell'intestazione JWT
`alg`	Algoritmo	`ES256`
`kid`	ID chiave	Deve corrispondere a una delle chiavi pubbliche elencate nel File di chiave IAP, disponibile in due diversi formati: `https://www.gstatic.com/iap/verify/public_key` e `https://www.gstatic.com/iap/verify/public_key-jwk`

Assicurati che il JWT sia stato firmato dalla chiave privata che corrisponde a la dichiarazione kid del token. Per farlo, devi prima recuperare la chiave pubblica da una delle due posizioni seguenti:

https://www.gstatic.com/iap/verify/public_key. Questo URL contiene un dizionario JSON che mappa i claim kid ai valori della chiave pubblica.
https://www.gstatic.com/iap/verify/public_key-jwk. Questo URL contiene le chiavi pubbliche IAP in formato JWK.

Una volta ottenuta la chiave pubblica, utilizza una libreria JWT per verificare la firma.

Verifica del payload JWT

Verifica che il payload del JWT sia conforme ai seguenti vincoli:

Dichiarazioni del payload JWT
`exp`	Scadenza	Deve essere una data futura. Il tempo è misurato in secondi dal lancio di di un'epoca. Attendi 30 secondi per il disallineamento. La durata massima di un token è di 10 minuti + 2 disallineamento.*
`iat`	Data/ora di emissione	Deve essere nel passato. Il tempo è misurato in secondi dal lancio di di un'epoca. Attendi 30 secondi per l'effetto di inclinazione.
`aud`	Pubblico	Deve essere una stringa con i seguenti valori: App Engine: `/projects/PROJECT_NUMBER/apps/PROJECT_ID` Compute Engine e GKE: `/projects/PROJECT_NUMBER/global/backendServices/SERVICE_ID`
`iss`	Emittente	Deve essere `https://cloud.google.com/iap`.
`hd`	Dominio dell'account	Se un account appartiene a un dominio ospitato, Viene fornita una dichiarazione `hd` per distinguere dominio a cui è associato l'account.
`google`	Rivendicazione di Google	Se uno o più livelli di accesso si applicano alla richiesta, i loro nomi vengono memorizzati all'interno dell'`google` l'oggetto JSON della dichiarazione, sotto la chiave `access_levels`, sotto forma di array di stringhe. Quando specifichi un criterio relativo ai dispositivi e l'organizzazione ha accesso ai dati del dispositivo, `DeviceId` viene archiviato anche nell'oggetto JSON. Tieni presente che una richiesta inviata a un'altra organizzazione potrebbe non avere l'autorizzazione per visualizzare i dati del dispositivo.

Puoi ottenere i valori per la stringa aud menzionata sopra accedendo alla console Google Cloud o utilizzando lo strumento a riga di comando gcloud.

Per ottenere valori stringa aud dalla console Google Cloud, vai a Impostazioni di Identity-Aware Proxy per il tuo progetto, fai clic su Altro accanto alla risorsa del bilanciatore del carico, quindi Seleziona Pubblico JWT con intestazione firmata. La finestra di dialogo JWT dell'intestazione firmata che mostra l'attestazione aud per la risorsa selezionata.

menu extra con l'opzione Pubblico JWT con intestazione firmata

Se vuoi utilizzare gcloud CLI a strumento a riga di comando gcloud per ottenere i valori della stringa aud, devi conoscere l'ID progetto. Puoi trovare l'ID progetto nella scheda Informazioni sul progetto della console Google Cloud, quindi eseguire i comandi specificati di seguito per ogni valore.

Numero progetto

Per ottenere il numero del progetto utilizzando lo strumento a riga di comando gcloud, esegui il seguente comando:

gcloud projects describe PROJECT_ID

Il comando restituisce un output simile al seguente:

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

ID servizio

Per ottenere l'ID servizio utilizzando lo strumento a riga di comando gcloud, esegui questo comando:

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

Il comando restituisce un output simile al seguente:

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

Recupero dell'identità utente

Se tutte le verifiche riportate sopra hanno esito positivo, recupera l'identità utente. Il payload del token ID contiene le seguenti informazioni utente:

Id utente del payload dell'ID token
`sub`	Oggetto	L'identificatore univoco e stabile dell'utente. Utilizza questo valore anziché l'intestazione `x-goog-authenticated-user-id`.
`email`	Email dell'utente	Indirizzo email dell'utente. Utilizza questo valore al posto del Intestazione `x-goog-authenticated-user-email`. A differenza dell'intestazione e della dichiarazione `sub`, questo valore non ha un prefisso dello spazio dei nomi.

Ecco un codice campione per proteggere un'app con IAP firmato intestazioni:

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

Test del codice di convalida

Se visiti l'app utilizzando secure_token_test parametri di query, IAP includerà un JWT non valido. Usalo per assicurarti che La logica di convalida JWT gestisce tutti i vari casi di errore e, per vedere come si comporta la tua app quando riceve un JWT non valido.

Creazione di un'eccezione per il controllo di integrità

Come accennato in precedenza, i controlli di salute di Compute Engine e GKE non utilizzano le intestazioni JWT e IAP non gestisce i controlli di salute. Dovrai configurare il controllo di integrità e l'app per consentire l'accesso al controllo di integrità.

configura il controllo di integrità

Se non hai già impostato un percorso per il controllo di integrità, utilizza Console Google Cloud per impostare un percorso non sensibile per il controllo di integrità. Marca per assicurarti che questo percorso non sia condiviso da altre risorse.

Vai alla console Google Cloud Controlli di integrità.
Vai alla pagina Controlli di integrità
Fai clic sul controllo di integrità in uso per la tua app, quindi su Modifica.
In Percorso richiesta, aggiungi un nome di percorso non sensibile. Questo specifica Percorso dell'URL utilizzato da Google Cloud per inviare richieste di controllo di integrità. Se omesso, la richiesta di controllo di integrità viene inviata all'indirizzo /.
Fai clic su Salva.

Configurazione della convalida JWT

Nel codice che chiama la routine di convalida JWT, aggiungi una condizione per 200 Stato HTTP per il percorso della richiesta di controllo di integrità. Ad esempio:

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

JWT per le identità esterne

Se utilizzi IAP con identità esterne, IAP emetterà comunque un JWT firmato su ogni autenticazione come avviene per le identità Google. Tuttavia, ci sono alcune le differenze.

Informazioni sul fornitore

Quando si utilizzano identità esterne, il payload JWT contiene un'attestazione denominato gcip. Questa dichiarazione contiene informazioni sull'utente, ad esempio l'indirizzo email e l'URL della foto, nonché eventuali attributi aggiuntivi specifici del fornitore.

Di seguito è riportato un esempio di JWT per un utente che ha eseguito l'accesso con 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"
}',

I campi `email` e `sub`

Se un utente è stato autenticato da Identity Platform, i email e sub campi del JWT avranno il prefisso dell'emittente del token di Identity Platform e l'ID tenant utilizzato (se presente). Ad esempio:

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

Controllo dell'accesso con `sign_in_attributes`

IAM non è supportato per l'uso con identità esterne, ma puoi utilizzare le rivendicazioni incorporate nel campo sign_in_attributes per controllare l'accesso . Ad esempio, considera un utente che ha eseguito l'accesso utilizzando un provider 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"
}

Puoi aggiungere all'applicazione una logica simile al codice seguente per limitare per accedere agli utenti con un ruolo valido:

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.
}

Attributi utente aggiuntivi dei provider SAML e OIDC di Identity Platform è accessibile utilizzando l'elemento gcipClaims.gcip.firebase.sign_in_attributes nidificato reclamo.

Limitazioni delle dimensioni delle attestazioni dell'IdP

Dopo che un utente accede a Identity Platform, gli attributi utente aggiuntivi verrà propagato al payload del token dell'ID della piattaforma di identità stateless, verrà trasferito in sicurezza a IAP. IAP quindi emetterà il proprio cookie opaco stateless che contiene anch'esso le stesse attestazioni. IAP genererà l'intestazione JWT firmata in base al cookie contenuti.

Di conseguenza, se una sessione viene avviata con un numero elevato di rivendicazioni, potrebbe superare le dimensioni massime consentite per i cookie, che in genere sono circa 4 KB nella maggior parte dei browser. L'operazione di accesso non riuscirà.

Devi assicurarti che solo le richieste necessarie vengano propagate in SAML dell'IdP o OIDC. Un'altra opzione è utilizzare funzioni di blocco da escludere reclami non necessari per la verifica dell'autorizzazione.

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,
    };
  }
});