Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

App mit signierten Headern sichern

Auf dieser Seite wird gezeigt, wie Sie Ihre Anwendung mit signierten IAP-Headern schützen können. Bei entsprechender Konfiguration sorgt Identity-Aware Proxy (IAP) mit JSON-Web-Tokens (JWTs) dafür, dass eine Anfrage an Ihre Anwendung autorisiert ist. So wird Ihre App vor den folgenden Risiken geschützt:

IAP wurde versehentlich deaktiviert
Falsch konfigurierte Firewalls
Nicht autorisierter Zugriff innerhalb des Projekts

Um Ihre App zu schützen, müssen Sie für alle App-Typen signierte Header verwenden.

Wenn Sie eine App in der App Engine-Standardumgebung haben, können Sie alternativ die Users API verwenden.

Compute Engine- und GKE-Systemdiagnosen enthalten keine JWT-Header und IAP verarbeitet keine Systemdiagnosen. Wenn die Systemdiagnose Zugriffsfehler zurückgibt, prüfen Sie, ob die Systemdiagnose in der Google Cloud Console richtig konfiguriert ist und ob die JWT-Header-Validierung den Systemdiagnosepfad zulässt. Weitere Informationen finden Sie unter Ausnahme für Systemdiagnose erstellen.

Hinweis

Um Ihre Anwendung mit signierten Headern zu schützen, muss Folgendes vorhanden sein:

Eine Anwendung, zu der Nutzer eine Verbindung herstellen sollen.
Eine JWT-Bibliothek eines Drittanbieters für Ihre Sprache, die den ES256-Algorithmus unterstützt

Anwendung mit IAP-Headern schützen

Für den Schutz Ihrer Anwendung mit dem IAP-JWT müssen Sie den Header, die Nutzlast und die Signatur des JWT prüfen. Das JWT befindet sich im HTTP-Anfrageheader x-goog-iap-jwt-assertion. Wenn ein Angreifer IAP umgeht, kann er die nicht signierten IAP-Identitätsheader x-goog-authenticated-user-{email,id} fälschen. Das IAP-JWT stellt dazu eine sicherere Alternative dar.

Signierte Header bieten eine sekundäre Sicherheit, wenn jemand IAP umgeht. Wenn IAP aktiviert ist, werden die vom Client bereitgestellten x-goog-*-Header entfernt, wenn die Anfrage die IAP-Bereitstellungsinfrastruktur durchläuft.

JWT-Header prüfen

Prüfen Sie, ob der Header des JWT den folgenden Anforderungen genügt:

Anforderungen an den JWT-Header
`alg`	Algorithmus	`ES256`
`kid`	Schlüssel-ID	Muss einem der öffentlichen Schlüssel entsprechen, die in der IAP-Schlüsseldatei aufgeführt und in zwei verschiedenen Formaten verfügbar sind: `https://www.gstatic.com/iap/verify/public_key` und `https://www.gstatic.com/iap/verify/public_key-jwk`.

Achten Sie darauf, dass das JWT mit dem privaten Schlüssel signiert wurde, der der kid-Anforderung des Tokens entspricht. Rufen Sie zuerst den öffentlichen Schlüssel von einem der beiden folgenden Orte ab:

https://www.gstatic.com/iap/verify/public_key. Diese URL enthält ein JSON-Wörterbuch, das die kid-Anforderungen den öffentlichen Schlüsselwerten zuordnet.
https://www.gstatic.com/iap/verify/public_key-jwk. Diese URL enthält die öffentlichen IAP-Schlüssel im Format JWK.

Nachdem Sie den öffentlichen Schlüssel erhalten haben, verwenden Sie eine JWT-Bibliothek, um die Signatur zu überprüfen.

IAP rotiert seine öffentlichen Schlüssel regelmäßig. Damit Sie die JWTs immer verifizieren können, lesen Sie den Abschnitt Caching öffentlicher Schlüssel automatisieren.

JWT-Nutzlast prüfen

Prüfen Sie, ob die Nutzlast des JWT den folgenden Anforderungen genügt:

Anforderungen an die JWT-Nutzlast
`exp`	Ablaufzeit	Muss in der Zukunft liegen. Die Zeit wird in Sekunden seit der UNIX-Epoche gemessen. Rechnen Sie rund 30 Sekunden Verzögerung ein. Die maximale Lebensdauer eines Tokens beträgt 10 Minuten + 2 Verzögerung.*
`iat`	Ausstellungszeit	Muss in der Vergangenheit liegen.j Die Zeit wird in Sekunden seit der UNIX-Epoche gemessen. Rechnen Sie rund 30 Sekunden Verzögerung ein.
`aud`	Zielgruppe	Muss ein String mit den folgenden Werten sein: App Engine: `/projects/PROJECT_NUMBER/apps/PROJECT_ID` Compute Engine und GKE: `/projects/PROJECT_NUMBER/global/backendServices/SERVICE_ID` Cloud Run: `/projects/PROJECT_NUMBER/locations/REGION/services/SERVICE_NAME`
`iss`	Aussteller	Muss `https://cloud.google.com/iap` lauten.
`hd`	Kontodomain	Wenn ein Konto zu einer gehosteten Domain gehört, wird die Anforderung `hd` bereitgestellt, um die Domain, der das Konto zugeordnet ist, identifizieren zu können.
`google`	Google-Anforderung	Wenn eine oder mehrere Zugriffsebenen für die Anfrage gelten, werden ihre Namen im JSON-Objekt der `google`-Anforderung unter dem Schlüssel `access_levels` als Array von Strings gespeichert. Wenn Sie eine Geräterichtlinie angeben und die Organisation Zugriff auf die Gerätedaten hat, wird die `DeviceId` auch im JSON-Objekt gespeichert. Beachten Sie, dass eine Anfrage an eine andere Organisation möglicherweise nicht die Berechtigung hat, die Gerätedaten aufzurufen.

Sie können die Werte für den oben genannten String aud über dieGoogle Cloud Console oder die Google Cloud CLI abrufen.

Wenn Sie aud-Stringwerte aus der Google Cloud Console abrufen möchten, rufen Sie die Identity-Aware Proxy-Einstellungen für Ihr Projekt auf, klicken Sie neben der Load-Balancer-Ressource auf Mehr und wählen Sie dann Signierte Header-JWT-Zielgruppe aus. Im Dialogfeld JWT mit signiertem Header wird die aud-Anforderung für die ausgewählte Ressource angezeigt.

Wenn Sie die gcloud CLI verwenden möchten, um die aud-Stringwerte abzurufen, müssen Sie die Projekt-ID kennen. Sie finden die Projekt-ID in der Google Cloud Console auf der Karte Projektinformationen. Führen Sie dann die angegebenen Befehle für jeden Wert aus.

Projektnummer

Führen Sie den folgenden Befehl aus, um Ihre Projektnummer mit der gcloud CLI abzurufen:

gcloud projects describe PROJECT_ID

Der Befehl gibt in etwa Folgendes zurück:

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

Dienst-ID

Führen Sie den folgenden Befehl aus, um Ihre Dienst-ID mit der gcloud CLI abzurufen:

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

Der Befehl gibt in etwa Folgendes zurück:

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

Nutzeridentität abrufen

Wenn alle vorherigen Überprüfungen erfolgreich sind, rufen Sie die Nutzeridentität ab. Die Nutzlast des ID-Tokens enthält folgende Nutzerinformationen:

Nutzeridentität in der Nutzlast des ID-Tokens
`sub`	Betreff	Die eindeutige, stabile Kennung für den Nutzer. Verwenden Sie diesen Wert anstelle des Headers `x-goog-authenticated-user-id`.
`email`	E-Mail-Adresse des Nutzers	Die E-Mail-Adresse des Nutzers. Verwenden Sie diesen Wert anstelle des Headers `x-goog-authenticated-user-email`. Im Gegensatz zu diesem Header und zur `sub`-Anforderung hat dieser Wert kein Namespace-Präfix.

Im Folgenden finden Sie Beispielcode zum Sichern einer Anwendung mit signierten IAP-Headern:

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

Validierungscode testen

Wenn Sie Ihre Anwendung mit den Abfrageparametern secure_token_test aufrufen, enthält IAP ein ungültiges JWT. Damit können Sie prüfen, ob Ihre JWT-Validierungslogik alle verschiedenen Fehlerfälle verarbeitet, und sehen, wie sich Ihre Anwendung verhält, wenn sie ein ungültiges JWT empfängt.

Ausnahme für Systemdiagnose erstellen

Wie bereits erwähnt, verwenden die Compute Engine- und GKE-Systemdiagnosen keine JWT-Header und IAP verarbeitet keine Systemdiagnosen. Sie müssen also die Systemdiagnose und die Anwendung so konfigurieren, dass der Zugriff auf die Systemdiagnose zulässig ist.

Systemdiagnose konfigurieren

Wenn Sie noch keinen Pfad für Ihre Systemdiagnose festgelegt haben, verwenden Sie dieGoogle Cloud Console, um einen nicht sensiblen Pfad für die Systemdiagnose festzulegen. Achten Sie darauf, dass dieser Pfad von keiner anderen Ressource verwendet wird.

Rufen Sie in der Google Cloud Console die Seite Systemdiagnosen auf.
Zur Seite „Systemdiagnosen“
Klicken Sie auf die Systemdiagnose, die Sie für Ihre Anwendung verwenden, und anschließend auf Bearbeiten.
Fügen Sie unter Anfragepfad einen nicht vertraulichen Pfadnamen hinzu. Damit wird der URL-Pfad angegeben, den Google Cloud beim Senden von Systemdiagnoseanfragen verwendet. Wenn Sie nichts angeben, wird die Systemdiagnoseanfrage an / gesendet.
Klicken Sie auf Speichern.

JWT-Validierung konfigurieren

Fügen Sie dem Code, der die JWT-Validierungsroutine aufruft, eine Bedingung hinzu, die den HTTP-Status 200 für den Systemdiagnoseanfragepfad ausgibt. Beispiel:

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

Caching des öffentlichen Schlüssels automatisieren

IAP rotiert seine öffentlichen Schlüssel regelmäßig. Damit Sie das IAP-JWT immer verifizieren können, empfehlen wir, die Schlüssel im Cache zu speichern, damit sie nicht für jede Anfrage von der öffentlichen URL abgerufen werden müssen. Außerdem sollten Sie den Prozess zum Aktualisieren des im Cache gespeicherten Schlüssels automatisieren. Dieser Ansatz ist besonders nützlich für Anwendungen, die in einer Umgebung mit Netzwerkeinschränkungen ausgeführt werden, z. B. in einem VPC Service Controls-Perimeter.

Ein VPC Service Controls-Perimeter kann den direkten Zugriff auf die öffentliche URL für die Schlüssel verhindern. Wenn Sie die Schlüssel in einem Cloud Storage-Bucket im Cache speichern, können Ihre Anwendungen sie von einem Standort innerhalb Ihres VPC-SC-Perimeters abrufen.

Mit der folgenden Terraform-Konfiguration wird eine Funktion in Cloud Run bereitgestellt, die die neuesten öffentlichen IAP-Schlüssel von https://www.gstatic.com/iap/verify/public_key-jwk abruft und in einem Cloud Storage-Bucket speichert. Ein Cloud Scheduler-Job löst diese Funktion alle 12 Stunden aus, um die Schlüssel auf dem neuesten Stand zu halten.

Diese Konfiguration umfasst Folgendes:

Erforderliche Google Cloud APIs aktiviert, um Cloud Run zu verwenden und Schlüssel zu speichern und im Cache zu speichern
Ein Cloud Storage-Bucket zum Speichern der abgerufenen öffentlichen IAP-Schlüssel
Einen Cloud Storage-Bucket zum Bereitstellen des Quellcodes von Cloud Run-Funktionen
Dienstkonten für Cloud Run Functions und Cloud Scheduler mit den entsprechenden IAM-Berechtigungen
Eine Python-Funktion zum Abrufen und Speichern von Schlüsseln
Ein Cloud Scheduler-Job, der die Funktion alle 12 Stunden auslöst

Verzeichnisstruktur

├── 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

Ersetzen Sie Folgendes:

BUCKET_NAME: der Name Ihres Cloud Storage-Bucket
OBJECT_NAME: der Name des Objekts, in dem Ihre Schlüssel gespeichert werden sollen

`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"
}

Ersetzen Sie Folgendes:

PROJECT_ID: Ihre Google Cloud -Projekt-ID
REGION: die Region, in der Ressourcen bereitgestellt werden sollen, z. B. us-central1
BUCKET_NAME: der Name des Cloud Storage-Bucket, in dem IAP-Schlüssel gespeichert werden
BUCKET_NAME_FUNCTION: der Name des Cloud Storage-Bucket, in dem der Quellcode der Cloud Run-Funktionen gespeichert wird

`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`

Erstellen Sie eine terraform.tfvars-Datei, um Ihre Projekt-ID anzugeben und Bucket-Namen bei Bedarf anzupassen:

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"

Mit Terraform bereitstellen

Speichern Sie die Dateien in der zuvor beschriebenen Verzeichnisstruktur.
Wechseln Sie in Ihrem Terminal zum Verzeichnis und initialisieren Sie Terraform:
```
terraform init
```
Planen Sie die Änderungen:
```
terraform plan
```
Übernehmen Sie die Änderung:
```
terraform apply
```

Dadurch wird die Infrastruktur bereitgestellt. Der Cloud Scheduler-Job löst die Funktion alle 12 Stunden aus, ruft die IAP-Schlüssel ab und speichert sie standardmäßig in gs://BUCKET_NAME/iap_public_keys.jwk. Ihre Anwendungen können die Schlüssel jetzt aus diesem Bucket abrufen.

Ressourcen bereinigen

Führen Sie die folgenden Befehle aus, um die von Terraform erstellten Ressourcen zu entfernen:

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

terraform destroy -auto-approve

Ersetzen Sie BUCKET_NAME durch den Cloud Storage-Bucket für Ihre Schlüssel.

Hinweis: Der Befehl gsutil ist erforderlich, da Terraform keine Cloud Storage-Buckets löscht, die Objekte enthalten, wenn die Versionsverwaltung aktiviert ist.

JWTs für externe Identitäten

Wenn Sie IAP mit externen Identitäten verwenden, gibt IAP wie bei Google-Identitäten weiterhin ein signiertes JWT bei jeder authentifizierten Anfrage aus. Es gibt jedoch einige Unterschiede.

Anbieterinformationen

Bei Verwendung externer Identitäten enthält die JWT-Nutzlast eine Anforderung namens gcip. Diese Anforderung enthält Nutzerinformationen wie die E-Mail-Adresse, die Foto-URL und alle zusätzlichen anbieterspezifischen Attribute.

Im Folgenden finden Sie ein Beispiel für das JWT eines Nutzers, der sich mit Facebook angemeldet hat:

"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"
}',

Die Felder `email` und `sub`

Wenn ein Nutzer von Identity Platform authentifiziert wurde, werden den Feldern email und sub des JWT der Tokenaussteller von Identity Platform und die verwendete Mandanten-ID (wenn vorhanden) vorangestellt. Beispiel:

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

Zugriff mit `sign_in_attributes` steuern

IAM unterstützt keine externen Identitäten, aber Sie können im Feld sign_in_attributes eingebettete Anforderungen verwenden, um den Zugriff zu steuern. Beispiel: Ein Nutzer ist über einen SAML-Anbieter angemeldet:

{
  "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"
}

Sie können der Anwendung dann eine Logik wie mit dem folgenden Code hinzufügen und so den Zugriff auf Nutzer mit einer gültigen Rolle einschränken:

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

Sie können über die verschachtelte Anforderung gcipClaims.gcip.firebase.sign_in_attributes auf zusätzliche Nutzerattribute von SAML- und OIDC-Anbietern von Identity Platform zugreifen.

Größenbeschränkungen für IdP-Ansprüche

Nachdem sich ein Nutzer mit der Identity Platform angemeldet hat, werden die zusätzlichen Nutzerattribute an die zustandslose Identity Platform-ID-Token-Nutzlast weitergegeben, die sicher an IAP übergeben wird. IAP gibt dann ein eigenes zustandsloses, intransparentes Cookie aus, das ebenfalls dieselben Anforderungen enthält. IAP generiert den signierten JWT-Header basierend auf dem Cookie-Inhalt.

Wenn eine Sitzung mit vielen Anforderungen initiiert wird, kann die maximal zulässige Cookie-Größe überschritten werden, die in den meisten Browsern normalerweise etwa 4 KB beträgt. Dies führt dazu, dass die Anmeldung fehlschlägt.

Achten Sie darauf, dass nur die erforderlichen Anforderungen in den IdP-SAML- oder OIDC-Attributen weitergegeben werden. Eine weitere Möglichkeit besteht darin, Blockierfunktionen zu verwenden, um die Anforderungen herauszufiltern, die für die Autorisierungsprüfung nicht erforderlich sind.

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

App mit signierten Headern sichern Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Hinweis

Anwendung mit IAP-Headern schützen

JWT-Header prüfen

JWT-Nutzlast prüfen

Nutzeridentität abrufen

C#

Go

Java

Node.js

PHP

Python

Ruby

Validierungscode testen

Ausnahme für Systemdiagnose erstellen

Systemdiagnose konfigurieren

JWT-Validierung konfigurieren

Caching des öffentlichen Schlüssels automatisieren

Verzeichnisstruktur

function_source/main.py

function_source/requirements.txt

variables.tf

main.tf

outputs.tf

terraform.tfvars

Mit Terraform bereitstellen

Ressourcen bereinigen

JWTs für externe Identitäten

Anbieterinformationen

Die Felder email und sub

Zugriff mit sign_in_attributes steuern

Größenbeschränkungen für IdP-Ansprüche

App mit signierten Headern sichern

`function_source/main.py`

`function_source/requirements.txt`

`variables.tf`

`main.tf`

`outputs.tf`

`terraform.tfvars`

Die Felder `email` und `sub`

Zugriff mit `sign_in_attributes` steuern