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 JSON Web Tokens (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:

Se ha inhabilitado por error la compra en la aplicación
Cortafuegos mal configurados
Acceso no autorizado desde el proyecto

Para proteger 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, también puedes usar la API Users.

Las comprobaciones del estado de Compute Engine y GKE no incluyen encabezados JWT y IAP no procesa las comprobaciones del estado. Si la comprobación del estado devuelve errores de acceso, asegúrate de que la comprobación del estado esté configurada correctamente en la consola y de que la validación del encabezado JWT permita la ruta de comprobación del estado. Google Cloud Para obtener más información, consulta el artículo 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 quieras 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. Cuando la compra en la aplicación está habilitada, IAP elimina los encabezados x-goog-* proporcionados por el cliente cuando la solicitud pasa por la infraestructura de servicio de IAP.

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 IAP, 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. 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.

IAP rota periódicamente sus claves públicas. Para asegurarte de que siempre puedes verificar los JWTs, consulta Automatizar el almacenamiento en caché de claves públicas.

Verificar la carga útil del JWT

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

Claims 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 desviación. El tiempo de vida máximo de un token es de 10 minutos + 2 skew.*
`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 desviació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` Cloud Run: `/projects/PROJECT_NUMBER/locations/REGION/services/SERVICE_NAME`
`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 dispositivos 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 laGoogle Cloud consola 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.

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 de proyecto en la tarjeta Google Cloud consola Información del proyecto y, a continuación, ejecutar los comandos especificados 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.

A continuación, se muestra un fragmento de código de ejemplo para proteger una aplicación con encabezados de compra 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 la 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 ninguna otra fuente 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

Automatizar el almacenamiento en caché de claves públicas

IAP rota sus claves públicas periódicamente. Para asegurarte de que siempre puedes verificar el JWT de las compras en la aplicación, te recomendamos que almacenes en caché las claves para no tener que obtenerlas de la URL pública en cada solicitud y que automatices el proceso de actualización de la clave almacenada en caché. Este enfoque es especialmente útil para las aplicaciones que se ejecutan en un entorno con restricciones de red, como un perímetro de Controles de Servicio de VPC.

Un perímetro de Controles de Servicio de VPC puede impedir el acceso directo a la URL pública de las claves. Al almacenar en caché las claves en un segmento de Cloud Storage, tus aplicaciones pueden obtenerlas desde una ubicación dentro de tu perímetro de VPC Service Controls.

La siguiente configuración de Terraform despliega una función en Cloud Run que obtiene las últimas claves públicas de IAP de https://www.gstatic.com/iap/verify/public_key-jwk y las almacena en un segmento de Cloud Storage. Una tarea de Cloud Scheduler activa esta función cada 12 horas para mantener las claves actualizadas.

Esta configuración incluye lo siguiente:

APIs necesarias Google Cloud habilitadas para usar Cloud Run y almacenar y claves de caché
Un segmento de Cloud Storage para almacenar las claves públicas de IAP obtenidas
Un segmento de Cloud Storage para almacenar el código fuente de las funciones de Cloud Run
Cuentas de servicio para funciones de Cloud Run y Cloud Scheduler con los permisos de gestión de identidades y accesos adecuados
Función de Python para obtener y almacenar claves
Una tarea de Cloud Scheduler para activar la función cada 12 horas

Estructura de directorios

├── function_source/
│   ├── main.py
│   └── requirements.txt
├── main.tf
├── outputs.tf
├── variables.tf
└── terraform.tfvars

`function_source/main.py`

import functions_framework
import requests
from google.cloud import storage
import os

# Environment variables to be set in the function configuration
BUCKET_NAME = os.environ.get("BUCKET_NAME")
OBJECT_NAME = os.environ.get("OBJECT_NAME", "iap_public_keys.jwk")
IAP_KEYS_URL = "https://www.gstatic.com/iap/verify/public_key-jwk"

@functions_framework.http
def update_iap_keys(request):
    """Fetches IAP public keys from the public URL and stores them in a Cloud Storage bucket."""
    if not BUCKET_NAME:
        print("Error: BUCKET_NAME environment variable not set.")
        return "BUCKET_NAME environment variable not set.", 500

    try:
        # Fetch the keys
        response = requests.get(IAP_KEYS_URL)
        response.raise_for_status()  # Raise an exception for bad status codes
        keys_content = response.text
        print(f"Successfully fetched keys from {IAP_KEYS_URL}")

        # Store in Cloud Storage
        storage_client = storage.Client()
        bucket = storage_client.bucket(BUCKET_NAME)
        blob = bucket.blob(OBJECT_NAME)

        blob.upload_from_string(keys_content, content_type='application/json')

        print(f"Successfully wrote IAP keys to gs://{BUCKET_NAME}/{OBJECT_NAME}")
        return f"Successfully updated {OBJECT_NAME} in bucket {BUCKET_NAME}", 200

    except requests.exceptions.RequestException as e:
        print(f"Error fetching keys from {IAP_KEYS_URL}: {e}")
        return f"Error fetching keys: {e}", 500
    except Exception as e:
        print(f"Error interacting with Cloud Storage: {e}")
        return f"Error interacting with Cloud Storage: {e}", 500

Haz los cambios siguientes:

BUCKET_NAME: el nombre de tu segmento de Cloud Storage
OBJECT_NAME: el nombre del objeto en el que se almacenarán tus claves.

`function_source/requirements.txt`

functions-framework==3.*
requests
google-cloud-storage

`variables.tf`

variable "project_id" {
  description = "The Google Cloud project ID."
  type        = string
  default     = PROJECT_ID
}

variable "region" {
  description = "The Google Cloud region."
  type        = string
  default     = "REGION"
}

variable "iap_keys_bucket_name" {
  description = "The name of the Cloud Storage bucket to store IAP keys."
  type        = string
  default     = BUCKET_NAME"
}

variable "function_source_bucket_name" {
  description = "The name of the Cloud Storage bucket to store the function source code."
  type        = string
  default     = "BUCKET_NAME_FUNCTION"
}

Haz los cambios siguientes:

PROJECT_ID: tu ID de proyecto Google Cloud
REGION: la región en la que se van a implementar los recursos (por ejemplo, us-central1).
BUCKET_NAME: el nombre del segmento de Cloud Storage que almacena las claves de IAP
BUCKET_NAME_FUNCTION: el nombre del segmento de Cloud Storage que almacena el código fuente de las funciones de Cloud Run

`main.tf`

terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = ">= 4.50.0"
    }
    google-beta = {
      source  = "hashicorp/google-beta"
      version = ">= 4.50.0"
    }
  }
}

provider "google" {
  project = var.project_id
  region  = var.region
}

provider "google-beta" {
  project = var.project_id
  region  = var.region
}

# Enable necessary APIs
resource "google_project_service" "services" {
  for_each = toset([
    "storage.googleapis.com",
    "cloudfunctions.googleapis.com",
    "run.googleapis.com", # Cloud Functions v2 uses Cloud Run
    "cloudscheduler.googleapis.com",
    "iamcredentials.googleapis.com",
    "cloudbuild.googleapis.com" # Needed for Cloud Functions deployment
  ])
  service            = each.key
  disable_on_destroy = false
}

# Cloud Storage Bucket to store the IAP public keys
resource "google_storage_bucket" "iap_keys_bucket" {
  name                        = var.iap_keys_bucket_name
  location                    = var.region
  uniform_bucket_level_access = true
  versioning {
    enabled = true
  }
  lifecycle {
    prevent_destroy = false # Set to true in production to prevent accidental deletion
  }
}

# Cloud Storage Bucket to store the Cloud Function source code
resource "google_storage_bucket" "function_source_bucket" {
  name                        = var.function_source_bucket_name
  location                    = var.region
  uniform_bucket_level_access = true
}

# Archive the function source code
data "archive_file" "function_source_zip" {
  type        = "zip"
  source_dir  = "${path.module}/function_source"
  output_path = "${path.module}/function_source.zip"
}

# Upload the zipped source code to the source bucket
resource "google_storage_bucket_object" "function_source_object" {
  name   = "function_source.zip"
  bucket = google_storage_bucket.function_source_bucket.name
  source = data.archive_file.function_source_zip.output_path
}

# Service Account for the Cloud Function
resource "google_service_account" "iap_key_updater_sa" {
  account_id   = "iap-key-updater"
  display_name = "IAP Key Updater Function SA"
}

# Grant the function's SA permission to write to the IAP keys bucket
resource "google_storage_bucket_iam_member" "keys_bucket_writer" {
  bucket = google_storage_bucket.iap_keys_bucket.name
  role   = "roles/storage.objectAdmin"
  member = "serviceAccount:${google_service_account.iap_key_updater_sa.email}"
}

# Cloud Function (v2)
resource "google_cloudfunctions2_function" "update_iap_keys_func" {
  provider = google-beta # CFv2 often has newer features in google-beta
  name     = "update-iap-keys-function"
  location = var.region

  build_config {
    runtime     = "python312"
    entry_point = "update_iap_keys"
    source {
      storage_source {
        bucket = google_storage_bucket.function_source_bucket.name
        object = google_storage_bucket_object.function_source_object.name
      }
    }
  }

  service_config {
    max_instance_count = 1
    available_memory   = "256M"
    timeout_seconds    = 60
    ingress_settings   = "ALLOW_ALL"
    service_account_email = google_service_account.iap_key_updater_sa.email
    environment_variables = {
      BUCKET_NAME = google_storage_bucket.iap_keys_bucket.name
      OBJECT_NAME = "iap_public_keys.jwk"
    }
  }

  depends_on = [
    google_project_service.services,
    google_storage_bucket_iam_member.keys_bucket_writer
  ]
}

# Service Account for the Cloud Scheduler job
resource "google_service_account" "iap_key_scheduler_sa" {
  account_id   = "iap-key-scheduler"
  display_name = "IAP Key Update Scheduler SA"
}

# Grant the Scheduler SA permission to invoke the Cloud Function
resource "google_cloudfunctions2_function_iam_member" "invoker" {
  provider       = google-beta
  project        = google_cloudfunctions2_function.update_iap_keys_func.project
  location       = google_cloudfunctions2_function.update_iap_keys_func.location
  cloud_function = google_cloudfunctions2_function.update_iap_keys_func.name
  role           = "roles/cloudfunctions.invoker"
  member         = "serviceAccount:${google_service_account.iap_key_scheduler_sa.email}"
}

# Cloud Scheduler Job
resource "google_cloud_scheduler_job" "iap_key_update_schedule" {
  name        = "iap-key-update-schedule"
  description = "Fetches IAP public keys and stores them in Cloud Storage every 12 hours"
  schedule    = "0 */12 * * *" # Every 12 hours
  time_zone   = "Etc/UTC"
  region      = var.region

  http_target {
    uri = google_cloudfunctions2_function.update_iap_keys_func.service_config[0].uri
    http_method = "POST"

    oidc_token {
      service_account_email = google_service_account.iap_key_scheduler_sa.email
    }
  }

  depends_on = [
    google_cloudfunctions2_function_iam_member.invoker,
    google_project_service.services
  ]
}

`outputs.tf`

output "iap_keys_bucket_url" {
  description = "The Cloud Storage bucket URL where IAP public keys are stored."
  value       = "gs://${google_storage_bucket.iap_keys_bucket.name}"
}

output "cloud_function_url" {
  description = "The URL of the Cloud Function endpoint that triggers key updates."
  value       = google_cloudfunctions2_function.update_iap_keys_func.service_config[0].uri
}

`terraform.tfvars`

Crea un archivo terraform.tfvars para especificar el ID de tu proyecto y personalizar los nombres de los contenedores si es necesario:

project_id = "your-gcp-project-id"
# Optional: Customize bucket names
# iap_keys_bucket_name = "custom-iap-keys-bucket"
# function_source_bucket_name = "custom-func-src-bucket"

Desplegar con Terraform

Guarda los archivos en la estructura de directorios descrita anteriormente.
Ve al directorio en tu terminal e inicializa Terraform:
```
terraform init
```
Planifica los cambios:
```
terraform plan
```
Aplica los cambios:
```
terraform apply
```

De esta forma, se implementa la infraestructura. La tarea de Cloud Scheduler activa la función cada 12 horas, obtiene las claves de IAP y las almacena en gs://BUCKET_NAME/iap_public_keys.jwk de forma predeterminada. Ahora, tus aplicaciones pueden obtener las claves de este contenedor.

Eliminar los recursos

Para eliminar los recursos creados por Terraform, ejecuta los siguientes comandos:

gsutil rm -a gs://BUCKET_NAME/**

terraform destroy -auto-approve

Sustituye BUCKET_NAME por el segmento de Cloud Storage de tus claves.

Nota: El comando gsutil es necesario porque Terraform no elimina los segmentos de Cloud Storage que contienen objetos cuando la gestión de versiones está habilitada.

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 del usuario, como su correo electrónico, la URL de la foto y 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 admite 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.
}

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

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. 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 muchas reclamaciones, puede superar 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.

Asegúrate 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 la 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.

Antes de empezar

Proteger una aplicación con encabezados de IAP

Verificar el encabezado JWT

Verificar la carga útil del JWT

Recuperar la identidad del usuario

C#

Go

Java

Node.js

PHP

Python

Ruby

Probar el código de validación

Crear una excepción de comprobación del estado

Configurar la comprobación del estado

Configurar la validación de JWT

Automatizar el almacenamiento en caché de claves públicas

Estructura de directorios

function_source/main.py

function_source/requirements.txt

variables.tf

main.tf

outputs.tf

terraform.tfvars

Desplegar con Terraform

Eliminar los recursos

JWTs para identidades externas

Información del proveedor

Campos email y sub

Controlar el acceso con sign_in_attributes

Limitaciones de tamaño de las reclamaciones de IdP

Proteger una aplicación con encabezados firmados

`function_source/main.py`

`function_source/requirements.txt`

`variables.tf`

`main.tf`

`outputs.tf`

`terraform.tfvars`

Campos `email` y `sub`

Controlar el acceso con `sign_in_attributes`