Protege tu aplicación con encabezados firmados

En esta página se describe cómo proteger tu aplicación con encabezados de IAP firmados. Cuando se configura, Identity-Aware Proxy (IAP) usa JSON Web Tokens (JWT) para garantizar que se autoricen las solicitudes a tu aplicación. Esto protege tu aplicación de los siguientes riesgos:

• Inhabilitaciones accidentales de IAP
• Firewalls mal configurados
• Accesos desde dentro del mismo proyecto

Para poder proteger debidamente tu aplicación, es necesario usar encabezados firmados con todo tipo de aplicaciones.

Opcionalmente, si tienes una aplicación que funciona en un entorno estándar de App Engine, puedes usar la API de usuarios.

Ten en cuenta que las verificaciones de estado de Compute Engine y GKE no incluyen encabezados de JWT y que IAP no controla estas verificaciones. Si la verificación de estado muestra errores de acceso, asegúrate de haberla configurado de forma correcta en la consola de Google Cloud y de que la validación del encabezado JWT permita la ruta de acceso de la verificación de estado. Para obtener más información, consulta cómo crear una excepción de verificación de estado.

Antes de comenzar

Para poder proteger tu aplicación con encabezados firmados, necesitarás los siguientes elementos:

• Una aplicación a la que quieras que se conecten los usuarios
• Una biblioteca de JWT de terceros para tu lenguaje que sea compatible con el algoritmo ES256

Protege tu aplicación con encabezados de IAP

Para proteger tu aplicación con JWT de IAP, verifica el encabezado, la carga útil y la firma del JWT. El JWT se encuentra en el encabezado de la solicitud HTTP x-goog-iap-jwt-assertion. Si un atacante omite IAP, puede falsificar los encabezados de identidad sin firmar de IAP, x-goog-authenticated-user-{email,id}. JWT de IAP proporciona una alternativa más segura.

Los encabezados firmados proporcionan seguridad adicional en caso de que una persona omita IAP. Ten en cuenta que, si IAP está activo, este quita los encabezados x-goog-* proporcionados por el cliente cuando la solicitud se procesa en su infraestructura de entrega.

Verifica el encabezado JWT

Comprueba que el encabezado JWT cumpla con las siguientes restricciones:

Reclamaciones del encabezado JWT
alg	Algoritmo	ES256
kid	ID de la clave	Debe corresponder a una de las claves públicas que aparecen en el archivo de claves de IAP, disponible en dos formatos diferentes: https://www.gstatic.com/iap/verify/public_key y https://www.gstatic.com/iap/verify/public_key-jwk

Asegúrate de que el JWT esté firmado por la clave privada que corresponda a la reclamación kid del token. Para ello, primero debes obtener la clave pública de uno de estos dos lugares:

• https://www.gstatic.com/iap/verify/public_key: Esta URL contiene un diccionario JSON que asigna las reclamaciones kid a los valores de clave pública
• https://www.gstatic.com/iap/verify/public_key-jwk: Esta URL contiene las claves públicas de IAP en formato JWK

Una vez que tengas la clave pública, utiliza una biblioteca de JWT para verificar la firma.

Verifica la carga útil de JWT

Comprueba que la carga útil de JWT cumpla con las siguientes restricciones:

Reclamaciones de la carga útil de JWT
exp	Hora de vencimiento	Debe ser en el futuro. El tiempo se mide en segundos transcurridos desde la época UNIX, con una tolerancia de 30 segundos debida al sesgo. El ciclo de vida máximo de un token es de 10 minutos + 2 × el sesgo
iat	Hora de emisión	Debe ser en el pasado. El tiempo se mide en segundos transcurridos desde la época UNIX, con una tolerancia de 30 segundos debida al sesgo
aud	Público	Debe ser una string con los siguientes valores: App Engine: /projects/PROJECT_NUMBER/apps/PROJECT_ID Compute Engine y GKE: /projects/PROJECT_NUMBER/global/backendServices/SERVICE_ID
iss	Emisor	Debe ser https://cloud.google.com/iap.
hd	Dominio de cuenta	Si una cuenta pertenece a un dominio alojado, se proporciona la reclamación hd para diferenciar el dominio con el que está asociada la cuenta.
google	Reclamación de Google	Si se aplican uno o más niveles de acceso a la solicitud, sus nombres se almacenan en el objeto JSON de la reclamación google, en la clave access_levels, como un array de cadenas. Cuando especificas una política de dispositivo y la organización tiene acceso a los datos del dispositivo, DeviceId también se almacena en el objeto JSON. Ten en cuenta que es posible que una solicitud que se dirija a otra organización no tenga permiso para ver los datos del dispositivo.

Puedes obtener los valores de la string aud mencionados anteriormente si accedes a la consola de Google Cloud, o puedes usar la herramienta de línea de comandos de gcloud.

Para obtener valores de cadena aud de la consola de Google Cloud, ve a la configuración de Identity-Aware Proxy de tu proyecto, haz clic en Más junto al recurso Balanceador de cargas y, luego, selecciona Público de JWT del encabezado firmado. El cuadro de diálogo JWT del encabezado firmado que aparece muestra la reclamación aud del recurso seleccionado.

Si quieres usar la herramienta de línea de comandos de gcloud gcloud CLI para obtener los valores de la cadena aud, deberás saber el ID del proyecto. Puedes encontrar el ID del proyecto en la tarjeta Información del proyecto de la consola de Google Cloud y, luego, ejecutar los comandos especificados a continuación para cada valor.

Número de proyecto

Para ver el número del proyecto con la herramienta de línea de comandos de gcloud, ejecuta el siguiente comando:

gcloud projects describe PROJECT_ID

El comando muestra resultados como el siguiente:

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

ID de servicio

Para ver el ID del servicio con la herramienta de línea de comandos de gcloud, ejecuta el siguiente comando:

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

El comando muestra resultados como el siguiente:

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

Recupera la identidad del usuario

Si todas las verificaciones anteriores se realizaron correctamente, recupera la identidad del usuario. La carga útil del token de ID contiene la siguiente información sobre el usuario:

Identidad del usuario de la carga útil del token de ID
sub	Asunto	El identificador estable y único del usuario; usa este valor en lugar del encabezado x-goog-authenticated-user-id
email	Correo electrónico del usuario	Dirección de correo electrónico del usuario. Usa este valor en lugar del encabezado x-goog-authenticated-user-email. A diferencia de ese encabezado y la reclamación sub, este valor no tiene un prefijo de espacio de nombres.

Este es un ejemplo de código para proteger una aplicación con encabezados de IAP firmados:

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

Prueba tu código de validación

Si visitas tu aplicación con los parámetros de consulta secure_token_test, IAP incluirá un JWT no válido. Usa esto para asegurarte de que la lógica de validación de JWT controle todos los casos de falla y para ver cómo se comporta tu aplicación cuando recibe un JWT no válido.

Crea una excepción de verificación de estado

Como se mencionó anteriormente, las verificaciones de estado de Compute Engine y GKE no usan encabezados JWT. Además, IAP no controla las verificaciones de estado. Por tanto, deberás configurar la verificación de estado y la aplicación para que permitan el acceso de las verificaciones de estado.

Configura la verificación de estado

Si aún no configuraste una ruta de acceso no sensible para la verificación de estado, usa la consola de Google Cloud. Asegúrate de que esta ruta de acceso no se comparta con ningún otro recurso.

1. Ve a la página Verificaciones de estado de la consola de Google Cloud.
   Ir a la página Verificaciones de estado
2. Haz clic en la verificación de estado que estés usando para tu aplicación, y, a continuación, haz clic en Editar.
3. En Solicitar ruta de acceso, agrega el nombre de una ruta no confidencial. Esto permite especificar la ruta de URL que usa Google Cloud cuando envía solicitudes de verificación de estado. Si se omite este paso, la solicitud de verificación de estado se envía a /.
4. Haz clic en Guardar.

Configura la validación de JWT

En el código que llama a la rutina de validación de JWT, agrega una condición que devuelve un estado HTTP 200 para la ruta de acceso de tu solicitud de verificación de estado. Por ejemplo:

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

JWT para identidades externas

Si usas IAP con identidades externas, IAP emitirá un JWT firmado en cada solicitud autenticada, tal como lo hace con las identidades de Google. Sin embargo, existen algunas diferencias.

Información del proveedor

Cuando usas identidades externas, la carga útil de JWT contendrá una reclamación llamada gcip, que contiene información sobre el usuario, como la URL de su foto y correo electrónico, así como cualquier atributo adicional específico del proveedor.

El siguiente es un ejemplo de un JWT para un usuario que accedió con Facebook:

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

Los campos email y sub

Si Identity Platform autenticó a un usuario, los campos email y sub del JWT tendrán como prefijo al emisor del token de Identity Platform y el ID de instancia utilizado (si existiera). Por ejemplo:

"email": "securetoken.google.com/PROJECT-ID/TENANT-ID:[e-mail]",
"sub": "securetoken.google.com/PROJECT-ID/TENANT-ID:gZG0yELPypZElTmAT9I55prjHg63"

Controla el acceso con sign_in_attributes

IAM no es compatible con las identidades externas, pero puedes usar reclamaciones incorporadas en el campo sign_in_attributes para controlar el acceso. Por ejemplo, considera que un usuario accedió con un proveedor de SAML:

{
  "aud": "/projects/project_number/apps/my_project_id",
  "gcip": '{
    "auth_time": 1553219869,
    "email": "[e-mail]",
    "email_verified": true,
    "firebase": {
      "identities": {
        "email": [
          "[e-mail]"
        ],
        "saml.myProvider": [
          "[e-mail]"
        ]
      },
      "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:[e-mail]",
  "exp": 1553220470,
  "iat": 1553219870,
  "iss": "https://cloud.google.com/iap",
  "sub": "securetoken.google.com/my_project_id/my_tenant_id:gZG0yELPypZElTmAT9I55prjHg63"
}

Podrías agregar a tu aplicación lógica similar al código que se encuentra a continuación para restringir el acceso a los usuarios con una función válida:

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

Se puede acceder a atributos de usuario adicionales desde los proveedores de OIDC y SAML de Identity Platform mediante la reclamación anidada gcipClaims.gcip.firebase.sign_in_attributes.

Limitaciones del tamaño de las reclamaciones de IdP

Después de que un usuario accede con Identity Platform, los atributos adicionales del usuario se propagarán a la carga útil del token de ID de Identity Platform sin estado que se pasará de forma segura a IAP. Luego, IAP emitirá su propia cookie opaca sin estado, que también contiene las mismas reclamaciones. IAP generará el encabezado JWT firmado en función del contenido de las cookies.

Como resultado, si se inicia una sesión con una gran cantidad de reclamaciones, es posible que supere el tamaño de cookie máximo permitido, que suele ser de aproximadamente 4 KB en la mayoría de los navegadores. Esto hará que falle la operación de acceso.

Debes asegurarte de que solo se propaguen las reclamaciones necesarias en los atributos OIDC o SAML del IdP. Otra opción es usar funciones de bloqueo para filtrar los reclamos que no son necesarios para la verificación de autorización.

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