Esta página se ha traducido con Cloud Translation API.

Proteger una 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 tokens web JSON (JWT) para asegurarse de que una solicitud a tu aplicación esté autorizada. De esta forma, tu aplicación estará protegida frente a los siguientes riesgos:

La compra en la aplicación se ha inhabilitado por error.
Cortafuegos mal configurados
Acceder desde el proyecto.

Para proteger correctamente tu aplicación, debes usar encabezados firmados en todos los tipos de aplicaciones.

Si tienes una aplicación del entorno estándar de App Engine, puedes usar la API Users.

Ten en cuenta que las comprobaciones del estado de Compute Engine y GKE no incluyen encabezados JWT y que IAP no gestiona las comprobaciones del estado. Si la comprobación del estado devuelve errores de acceso, asegúrate de que esté configurada correctamente en la consola Google Cloud y de que la validación del encabezado JWT permita la ruta de comprobación del estado. Para obtener más información, consulta el artículo sobre cómo crear una excepción de comprobación de estado.

Antes de empezar

Para proteger tu aplicación con encabezados firmados, necesitarás lo siguiente:

Una aplicación a la que quieres que se conecten los usuarios.
Una biblioteca JWT de terceros para tu idioma que admita el algoritmo ES256.

Proteger una aplicación con encabezados de IAP

Para proteger tu aplicación con el 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 elude IAP, puede falsificar los encabezados de identidad sin firmar de IAP, x-goog-authenticated-user-{email,id}. El JWT de IAP ofrece una alternativa más segura.

Los encabezados firmados proporcionan seguridad secundaria en caso de que alguien eluda IAP. Ten en cuenta que, cuando se activa la compra en la aplicación, se eliminan los encabezados x-goog-* proporcionados por el cliente cuando la solicitud pasa por la infraestructura de servicio de la compra en la aplicación.

Verificar el encabezado JWT

Verifica que el encabezado del JWT cumpla las siguientes restricciones:

Reclamaciones de encabezado JWT
`alg`	Algoritmo	`ES256`
`kid`	ID de clave	Debe corresponderse con una de las claves públicas que aparecen en el archivo de claves de compras en aplicaciones, que está disponible en dos formatos: `https://www.gstatic.com/iap/verify/public_key` y `https://www.gstatic.com/iap/verify/public_key-jwk`.

Asegúrate de que el JWT se haya firmado con la clave privada que corresponde a la reclamación kid del token. Para ello, primero obtén la clave pública de uno de estos dos sitios:

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 las compras en aplicaciones en formato JWK.

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

Verificar la carga útil del JWT

Verifica que la carga útil del JWT cumpla las siguientes restricciones:

Reclamaciones de la carga útil de JWT
`exp`	Plazo de vencimiento	Debe ser una fecha posterior a la actual. El tiempo se mide en segundos desde el inicio del registro de tiempo de UNIX. Espera 30 segundos para que se produzca la inclinación. El tiempo de vida máximo de un token es de 10 minutos más 2 veces la diferencia.
`iat`	Hora de emisión	Debe ser una fecha anterior a la actual. El tiempo se mide en segundos desde el inicio del registro de tiempo de UNIX. Espera 30 segundos para que se produzca la inclinación.
`aud`	Audiencia	Debe ser una cadena 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 la cuenta	Si una cuenta pertenece a un dominio alojado, se proporciona la reclamación `hd` para diferenciar el dominio al que está asociada la cuenta.
`google`	Reclamación de Google	Si se aplican uno o varios 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 una matriz de cadenas. Cuando especificas una política de dispositivo y la organización tiene acceso a los datos del dispositivo, el `DeviceId` también se almacena en el objeto JSON. Ten en cuenta que es posible que una solicitud dirigida a otra organización no tenga permiso para ver los datos del dispositivo.

Puedes obtener los valores de la cadena aud mencionada anteriormente accediendo a la consolaGoogle Cloud o usando la herramienta de línea de comandos gcloud.

Para obtener valores de cadena aud Google Cloud de la consola, vaya a la configuración de Identity-Aware Proxy de su proyecto, haga clic en Más junto al recurso de balanceador de carga y, a continuación, seleccione Audiencia de JWT de encabezado firmado. En el cuadro de diálogo JWT de encabezado firmado que aparece, se muestra la reclamación aud del recurso seleccionado.

Menú adicional con la opción Audiencia de JWT de encabezado firmado

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

Número de proyecto

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

gcloud projects describe PROJECT_ID

El comando devuelve un resultado 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 obtener el ID de tu servicio con la herramienta de línea de comandos gcloud, ejecuta el siguiente comando:

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

El comando devuelve un resultado 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

Recuperar la identidad del usuario

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

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

Aquí tienes un ejemplo de código para proteger una aplicación con encabezados de compras en la aplicación 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

Probar el 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. Úsalo para asegurarte de que tu lógica de validación de JWT gestione todos los casos de error y para ver cómo se comporta tu aplicación cuando recibe un JWT no válido.

Crear una excepción de comprobación del estado

Como se ha mencionado anteriormente, las comprobaciones de estado de Compute Engine y GKE no usan encabezados JWT, y IAP no gestiona las comprobaciones de estado. Tendrás que configurar la comprobación del estado y la aplicación para permitir el acceso a la comprobación del estado.

Configurar la comprobación del estado

Si aún no has definido una ruta para la comprobación del estado, usa la consolaGoogle Cloud para definir una ruta no sensible para la comprobación del estado. Asegúrate de que ningún otro recurso comparta esta ruta.

Ve a la página Comprobaciones de estado de la consola. Google Cloud
Ve a la página Comprobaciones del estado.
Haz clic en la comprobación de estado que estés usando en tu aplicación y, a continuación, en Editar.
En Ruta de solicitud, añade un nombre de ruta que no sea sensible. Especifica la ruta de URL que usa Google Cloud al enviar solicitudes de comprobación del estado. Si se omite, la solicitud de comprobación del estado se envía a /.
Haz clic en Guardar.

Configurar la validación de JWT

En el código que llama a la rutina de validación de JWT, añade una condición para que se devuelva un estado HTTP 200 en la ruta de la solicitud de comprobación del estado. Por ejemplo:

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

JWTs para identidades externas

Si usas IAP con identidades externas, IAP seguirá emitiendo un JWT firmado en cada solicitud autenticada, al igual que con las identidades de Google. Sin embargo, hay algunas diferencias.

Información del proveedor

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

A continuación, se muestra un ejemplo de un JWT de un usuario que ha iniciado sesión 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"
}',

Campos `email` y `sub`

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

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

Controlar el acceso con `sign_in_attributes`

IAM no se puede usar con identidades externas, pero puedes usar las reclamaciones insertadas en el campo sign_in_attributes para controlar el acceso. Por ejemplo, supongamos que un usuario ha iniciado sesión con un proveedor de 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"
}

Puedes añadir a tu aplicación una lógica similar al código que se muestra a continuación para restringir el acceso a los usuarios que tengan un rol válido:

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 de proveedores SAML y OIDC de Identity Platform mediante la reclamación gcipClaims.gcip.firebase.sign_in_attributes anidada.

Limitaciones de tamaño de las reclamaciones de IdP

Cuando un usuario inicia sesión con Identity Platform, los atributos de usuario adicionales se propagan a la carga útil del token de ID de Identity Platform sin estado, que se transfiere de forma segura a IAP. A continuación, 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 la cookie.

Por lo tanto, si se inicia una sesión con un gran número de reclamaciones, es posible que se supere el tamaño máximo permitido de las cookies, que suele ser de unos 4 KB en la mayoría de los navegadores. Esto provocará que falle la operación de inicio de sesión.

Debe asegurarse de que solo se propaguen las reclamaciones necesarias en los atributos SAML u OIDC del proveedor de identidades. Otra opción es usar funciones de bloqueo para filtrar las reclamaciones que no sean necesarias para la comprobació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,
    };
  }
});

Proteger una aplicación con encabezados firmados Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.