Diese Seite wurde von der Cloud Translation API übersetzt.

Zertifikatbasierten Zugriff für Webanwendungen aktivieren

Auf dieser Seite wird beschrieben, wie Sie den zertifikatbasierten Zugriff (Certificate-Based Access, CBA) für Ihre Webanwendungen aktivieren. Mit der clientzertifikatbasierten Authentifizierung können Sie den Zugriff von vertrauenswürdigen Geräten auf Unternehmenswebanwendungen, die auf Google Cloudausgeführt werden, sichern.

Übersicht

Für die clientzertifikatbasierte Authentifizierung für Webanwendungen werden die Funktionen für den kontextsensitiven Zugriff von Chrome Enterprise Premium undGoogle Cloud -Netzwerke verwendet, um den Zugriff mit gegenseitigem TLS (mTLS) zu sichern. Im Folgenden finden Sie die Hauptkomponenten, mit denen Sie die clientbasierte Authentifizierung für Webanwendungen aktivieren:

Access Context Manager: Mit diesem Tool können Sie Zugriffsebenen erstellen, die Zertifikate erfordern, um den Zugriff auf Webanwendungen zu bestimmen.
Identity-Aware Proxy (IAP): Authentifiziert den Nutzerzugriff auf Webanwendungen.
Google Cloud HTTPS-Load-Balancer: Bietet gegenseitige Authentifizierung (mTLS) zwischen Nutzern und Webanwendungen.
Chrome Enterprise-Richtlinie: Ermöglicht die gegenseitige Authentifizierung (mTLS) zwischen Nutzern und Webanwendungen bei Verwendung des Chrome-Browsers.

Hinweise

Prüfen Sie mit dem folgenden Befehl, ob Sie eine aktuelle Version der Google Cloud CLI haben:

gcloud components update

mTLS für den externen HTTPS-Load-Balancer einrichten

Folgen Sie der Anleitung, um den externen HTTPS-Load-Balancer einzurichten. Notieren Sie sich den Namen des erstellten HTTPS-Ziel-Proxys, da Sie ihn in einem späteren Schritt benötigen.

Vertrauenskonfiguration erstellen

Erstellen Sie eine Vertrauenskonfiguration, um Ihre Art von Public-Key-Infrastruktur (PKI) darzustellen.

Für diese Aufgabe benötigen Sie die Berechtigung certificatemanager.trustconfigs.create für das Zielprojekt Google Cloud .

Sie können eine Vertrauenskonfiguration mit einem von Google ausgestellten Zertifikat (Methode 1), mit einem eigenen Zertifikat (Methode 2) oder mit einem selbst signierten Zertifikat mit Endpoint Verification (Methode 3) erstellen.

1. Methode

Verwenden Sie ein von Google ausgestelltes Zertifikat, um eine Vertrauenskonfiguration zu erstellen.

Führen Sie die Schritte zum Erstellen einer Stamm-CA aus.
Rufen Sie den Inhalt der PEM-Datei ab:
```
gcloud privateca roots describe ROOT_CA_ID \
    --pool=POOL_ID \
    --location=CA_LOCATION \
    --format='value(pemCaCertificates)'
```
Ersetzen Sie Folgendes:
- ROOT_CA_ID: Die ID des Root-Zertifikats.
- POOL_ID: Die ID des Pools für das Root-Zertifikat.
- CA_LOCATION: Der CA-Standort.
Rufen Sie das Root-Zertifikat ab, das im Feld pemCaCertificates zurückgegeben wird. Das Zertifikat ist der String zwischen den Markierungen BEGIN CERTIFICATE und END CERTIFICATE und umfasst beide Markierungen.
Speichern Sie das Root-Zertifikat im PEM-Format in einer Datei.
Konfiguration der Vertrauensstellung erstellen:
1. Legen Sie die folgenden Umgebungsvariablen fest:
```
ROOT_PEM_FILE=TRUST_ANCHOR_PATH
INT_PEM_FILE1=IM_CERT_PATH
INT_PEM_FILE2=SECOND_IM_CERT_PATH
```
  Ersetzen Sie Folgendes:
  - TRUST_ANCHOR_PATH: Der Pfad zu Ihrem PEM-codierten Vertrauensanker.
  - IM_CERT_PATH: Der Pfad zu Ihrem PEM-codierten Zwischenzertifikat.
  - SECOND_IM_CERT_PATH: Der Pfad zu Ihrem zweiten PEM-codierten Zwischenzertifikat.
2. Bereiten Sie den Inhalt der YAML-Datei für die Vertrauenskonfiguration vor:
```
ROOT=$(cat ROOT_PEM_FILE | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
INT_1=$(cat INT_PEM_FILE1 | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
INT_2=$(cat INT_PEM_FILE2 | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
```
3. Erstellen Sie die YAML-Datei für die Vertrauenskonfiguration:
```
cat << EOF > trust_config.yaml
name: "${TRUST_CONFIG_NAME?}"
trustStores:
- trustAnchors:
  - pemCertificate: "${ROOT?}"
  intermediateCas:
  - pemCertificate: "${INT_1?}"
  - pemCertificate: "${INT_2?}"
 EOF
```
  In dieser YAML-Datei wird eine Vertrauenskonfiguration mit dem Namen TRUST_CONFIG_NAME definiert. Die Vertrauenskonfiguration enthält einen Trust Store mit dem Root-Zertifikat und zwei Zwischenzertifikaten.
4. Importieren Sie die Vertrauenskonfiguration in den Google Cloud Zertifikatsmanager:
```
gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME \
  --project=GCP_PROJECT \
  --source=${PWD?}/trust_config.yaml
```
  Ersetzen Sie Folgendes:
  - TRUST_CONFIG_NAME: Der Name Ihrer Vertrauenskonfiguration.
  - GCP_PROJECT: Die Google Cloud -Projekt-ID.

Wenn Sie eine komplexere Struktur mit Zwischen-CAs bereitstellen, die von der Stamm-CA signiert wurden, müssen Sie die Zwischen-CAs als intermediateCAs hinzufügen.

2. Methode

Verwenden Sie Ihre eigene PKI-Bereitstellung mit vorhandenen Zertifikaten, um eine Vertrauenskonfiguration zu erstellen.

Bei dieser Art von Vertrauenskonfiguration wird von einem einfachen Vertrauensspeicher mit einem einzelnen Vertrauensanker ausgegangen, der ein Stammzertifikat darstellt. Es sind keine Zwischenzertifikate angegeben.

Konfiguration der Vertrauensstellung erstellen:

Legen Sie die folgenden Umgebungsvariablen fest:
```
ROOT_PEM_FILE=TRUST_ANCHOR_PATH
INT_PEM_FILE1=IM_CERT_PATH
INT_PEM_FILE2=SECOND_IM_CERT_PATH
```
Ersetzen Sie Folgendes:
- TRUST_ANCHOR_PATH: Der Pfad zu Ihrem PEM-codierten Vertrauensanker.
- IM_CERT_PATH: Der Pfad zu Ihrem PEM-codierten Zwischenzertifikat.
- SECOND_IM_CERT_PATH: Der Pfad zu Ihrem zweiten PEM-codierten Zwischenzertifikat.

Bereiten Sie den Inhalt der YAML-Datei für die Vertrauenskonfiguration vor:

ROOT=$(cat ROOT_PEM_FILE | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
INT_1=$(cat INT_PEM_FILE1 | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')
INT_2=$(cat INT_PEM_FILE2 | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')

Erstellen Sie die YAML-Datei für die Vertrauenskonfiguration:
```
cat << EOF > trust_config.yaml
name: "${TRUST_CONFIG_NAME?}"
trustStores:
- trustAnchors:
  - pemCertificate: "${ROOT?}"
  intermediateCas:
  - pemCertificate: "${INT_1?}"
  - pemCertificate: "${INT_2?}"
EOF
```
In dieser YAML-Datei wird eine Vertrauenskonfiguration mit dem Namen TRUST_CONFIG_NAME definiert. Die Vertrauenskonfiguration enthält einen Trust Store mit dem Root-Zertifikat und zwei Zwischenzertifikaten.
Importieren Sie die Vertrauenskonfiguration in den Google Cloud Zertifikatsmanager:
```
gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME \
  --project=GCP_PROJECT \
  --source=${PWD?}/trust_config.yaml
```
Ersetzen Sie Folgendes:
- TRUST_CONFIG_NAME: Der Name Ihrer Vertrauenskonfiguration.
- GCP_PROJECT: Die Google Cloud -Projekt-ID.

Methode 3

Wenn Sie den Chrome-Browser verwenden und ein selbst signiertes Zertifikat mit der Endpunktprüfung verwenden möchten, folgen Sie der Anleitung in diesem Abschnitt.

Folgen Sie der Anleitung, um die Endpunktprüfung für Ihre Organisation bereitzustellen. Bei der Endpunktprüfung wird automatisch ein von Google ausgestelltes, selbstsigniertes Zertifikat auf Ihren Geräten bereitgestellt. Sie müssen keine Vertrauenskonfiguration erstellen.

TLS-Richtlinie erstellen, um mTLS für den externen Load Balancer zu aktivieren

Wenn Sie Methode 3 verwendet haben, können Sie diesen Schritt überspringen.

Für diese Aufgabe benötigen Sie die folgenden Berechtigungen:

certificatemanager.trustconfigs.use für die Vertrauenskonfiguration, die Sie für dieses ServerTlsPolicy erstellt haben
networksecurity.serverTlsPolicies.create für das Zielprojekt Google Cloud

Erstellen Sie die YAML-Datei für die Server-TLS-Richtlinie:
```
cat << EOF > server_tls_policy.yaml
name: "SERVER_TLS_POLICY_NAME"
mtlsPolicy:
  clientValidationMode: ALLOW_INVALID_OR_MISSING_CLIENT_CERT
  clientValidationTrustConfig: projects/GCP_PROJECT/locations/global/trustConfigs/TRUST_CONFIG_NAME
EOF
```
Ersetzen Sie Folgendes:
- SERVER_TLS_POLICY_NAME: Der Name der TLS-Serverrichtlinie.
- GCP_PROJECT: Die Google Cloud -Projekt-ID.
- TRUST_CONFIG_NAME: Die Vertrauenskonfiguration, die Sie in einem vorherigen Schritt erstellt haben.
Informationen zu den Clientvalidierungsoptionen für clientValidationMode finden Sie unter mTLS-Clientvalidierungsmodi.

Importieren Sie die YAML-Datei der Server-TLS-Richtlinie in das Google Cloud -Projekt:

gcloud network-security server-tls-policies import ${SERVER_TLS_POLICY_NAME?} \
  --project=GCP_PROJECT \
  --source=${PWD?}/server_tls_policy.yaml \
  --location=global

Ersetzen Sie GCP_PROJECT durch die Google Cloud Projekt-ID.

Nachdem Sie eine TLS-Richtlinie erstellt haben, können Sie sie nicht mehr ändern. Wenn Sie Änderungen an einer vorhandenen TLS-Richtlinie vornehmen möchten, löschen Sie die vorhandene TLS-Richtlinie und erstellen Sie eine neue.

TLS-Richtlinie an einen Ziel-HTTPS-Proxy anhängen

Für diese Aufgabe benötigen Sie die Berechtigung compute.targetHttpsProxies.get für das Zielprojekt Google Cloud .

Exportieren Sie Ihren vorhandenen HTTPS-Zielproxy in eine lokale Datei:

gcloud compute target-https-proxies export TARGET_HTTPS_PROXY_NAME \
    --project=GCP_PROJECT \
    --global \
    --destination=${PWD?}/xlb-mtls-target-proxy.yaml

Ersetzen Sie Folgendes:

TARGET_HTTPS_PROXY_NAME: Der HTTPS-Zielproxy.
GCP_PROJECT: Die Google Cloud -Projekt-ID.

Hängen Sie ServerTlsPolicy an die Ziel-HTTPS-Proxykonfiguration an:

Für diese Aufgabe benötigen Sie die folgenden Berechtigungen:
- networksecurity.serverTlsPolicies.use für die von Ihnen erstellte ServerTlsPolicy für den Ziel-HTTPS-Proxy
- compute.targetHttpsProxies.update für das Zielprojekt Google Cloud
```
echo "serverTlsPolicy:
//networksecurity.googleapis.com/projects/GCP_PROJECT/locations/global/serverTlsPolicies/SERVER_TLS_POLICY_NAME" >> xlb-mtls-target-proxy.yaml
```
Ersetzen Sie Folgendes:
- GCP_PROJECT: Die Google Cloud -Projekt-ID.
- SERVER_TLS_POLICY_NAME: Die TLS-Serverrichtlinie.
Aktualisieren Sie den Ziel-HTTPS-Proxy, indem Sie die neue Konfiguration aus der lokalen Datei importieren:
```
gcloud compute target-https-proxies import TARGET_HTTPS_PROXY_NAME \
    --project=GCP_PROJECT \
    --global \
    --source=${PWD?}/xlb-mtls-target-proxy.yaml
```
Ersetzen Sie Folgendes:
- TARGET_HTTPS_PROXY_NAME: Der HTTPS-Zielproxy.
- GCP_PROJECT: Die Google Cloud -Projekt-ID.

Zugriffsebene erstellen, für die Zertifikate erforderlich sind

Console

Folgen Sie der Anleitung zum Erstellen einer benutzerdefinierten Zugriffsebene.
Fügen Sie Ihrer benutzerdefinierten Zugriffsebene den folgenden Ausdruck hinzu:

Wenn Sie eine Vertrauenskonfiguration erstellt haben (Methode 1 oder Methode 2), fügen Sie den folgenden Ausdruck in das Feld Bedingungen Ihrer benutzerdefinierten Zugriffsebene ein, um die PKI-Attestierungsbindung bei der Authentifizierung zu verwenden:
```
certIsPkiAttested(origin, ["TLS_POLICY_FULL_RESOURCE_PATH1", "TLS_POLICY_FULL_RESOURCE_PATH2", …]) == true
```
Dabei sind TLS_POLICY_FULL_RESOURCE_PATH1 und TLS_POLICY_FULL_RESOURCE_PATH2 die Pfade, die mehrere Vertrauenskonfigurationen darstellen: certificatemanager.googleapis.com/projects/GCP_PROJECT/locations/global/trustConfigs/TRUST_CONFIG_NAME.

Sie müssen mindestens einen Pfad für die Vertrauenskonfiguration angeben.

Ersetzen Sie Folgendes:
- GCP_PROJECT: Die Google Cloud -Projekt-ID.
- TRUST_CONFIG_NAME: Der Name Ihrer Vertrauenskonfiguration.
Wenn Sie ein von Google ausgestelltes, selbstsigniertes Zertifikat (Methode 3) verwendet haben, fügen Sie den folgenden Ausdruck in das Feld Bedingungen Ihrer benutzerdefinierten Zugriffsebene ein, um die Zertifikatsbindung bei der Authentifizierung zu verwenden:
```
certificateBindingState(origin, device) == CertificateBindingState.CERT_MATCHES_EXISTING_DEVICE
```

gcloud

Wenn Sie eine Vertrauenskonfiguration erstellt haben (Methode 1 oder Methode 2), führen Sie den folgenden Befehl aus, um eine benutzerdefinierte Zugriffsebene zu erstellen, die bei der Authentifizierung die PKI-Attestierungsbindung verwendet:

gcloud access-context-manager levels create ACCESS_LEVEL_NAME \
    --title=TITLE \
    --custom-level-spec=FILE \
    --description=DESCRIPTION \
    --policy=POLICY_NAME

Ersetzen Sie Folgendes:

ACCESS_LEVEL_NAME: Ein eindeutiger Name für die Zugriffsebene.
TITLE: Ein für Menschen lesbarer Titel.
FILE: Eine YAML-Datei, die den folgenden Ausdruck enthält:

certIsPkiAttested(origin, ["TLS_POLICY_FULL_RESOURCE_PATH1", "TLS_POLICY_FULL_RESOURCE_PATH2", …]) == true

Dabei sind TLS_POLICY_FULL_RESOURCE_PATH1 und TLS_POLICY_FULL_RESOURCE_PATH2 die Pfade, die mehrere Vertrauenskonfigurationen darstellen: certificatemanager.googleapis.com/projects/GCP_PROJECT/locations/global/trustConfigs/TRUST_CONFIG_NAME.

Sie müssen mindestens einen Pfad für die Vertrauenskonfiguration angeben.

Ersetzen Sie Folgendes:
- GCP_PROJECT: Die Google Cloud -Projekt-ID.
- TRUST_CONFIG_NAME: Der Name Ihrer Vertrauenskonfiguration.
DESCRIPTION: Ausführliche Beschreibung der Zugriffsebene.
POLICY_NAME: Die Zugriffsrichtlinie Ihrer Organisation.

Wenn Sie keine Vertrauenskonfiguration haben, weil Sie ein selbstsigniertes Zertifikat mit der Endpunktprüfung (Methode 3) verwenden, fügen Sie den folgenden Ausdruck in Ihre benutzerdefinierte Zugriffsebene ein:

certificateBindingState(origin, device) == CertificateBindingState.CERT_MATCHES_EXISTING_DEVICE

Zertifikatbasierten Zugriff mit Identity-Aware Proxy (IAP) erzwingen

In der Architektur für die clientbasierte Authentifizierung für Webanwendungen bietet IAP die hauptkontobasierte Richtlinienerzwingung, um Ihre Webanwendungen vor nicht vertrauenswürdigen Geräten zu schützen.

Führen Sie die folgenden Schritte aus, um IAP zu aktivieren und die CBA-Richtlinie zu konfigurieren:

Wenn Sie IAP noch nicht eingerichtet haben, folgen Sie dieser Anleitung.
Rufen Sie IAP auf, um die zuvor erstellte Zugriffsebene anzuhängen:
IAP aufrufen
Wählen Sie die Ressource aus, die Sie mit CBA sichern möchten, und klicken Sie dann auf Einstellungen.
Geben Sie in das Feld Zugriffsebenen den Namen der von Ihnen erstellten Zugriffsebene ein.

Wenn Sie die Google Cloud CLI zum Konfigurieren einer CBA-Richtlinie in IAP verwenden möchten, lesen Sie die Google Cloud CLI-Dokumentation.

Browser so konfigurieren, dass das Zertifikat automatisch ausgewählt wird

Damit Ihr Browser das Zertifikat automatisch auswählt, wenn er den Zugriff bestimmt, führen Sie die Schritte für Ihren Browser aus.

Chrome

Konfigurieren Sie die Chrome-Richtlinie AutoSelectCertificateForURLs so, dass Chrome während des mTLS-Handshakes das richtige Zertifikat verwendet.

Prüfen Sie, ob der Chrome-Browser über die Chrome-Verwaltung über die Cloud oder über Windows-Gruppenrichtlinien verwaltet wird:
- Windows, macOS und Linux: Führen Sie die Schritte zum Einrichten eines verwalteten Chrome-Profils aus.
- Chrome: Registrieren Sie das Gerät für das Unternehmen.
Fügen Sie die AutoSelectCertificateForUrls-Richtlinie hinzu:
1. Rufen Sie in der Admin-Konsole Geräte > Chrome > Einstellungen > Nutzer- und Browsereinstellungen > Clientzertifikate auf.
2. Wählen Sie eine Organisation aus.
3. Fügen Sie eine AutoSelectCertificateForUrls-Richtlinie für die URL Ihrer Webanwendung und Informationen zum Root-Zertifikat hinzu.

Weitere Informationen finden Sie in der Dokumentation zum Richtlinienschema. Im Folgenden finden Sie ein Beispiel für eine Richtlinienkonfiguration, in der das Zertifikat aus der Endpunktprüfung verwendet wird:

{
  "pattern":"https://[*.].mysite.com",
  "Filter":{
    "ISSUER":{
      "CN":"Google Endpoint Verification"
    }
  }
}

Safari

Identitätseinstellung konfigurieren:

Öffnen Sie die Schlüsselbundverwaltung und wählen Sie Alle Objekte aus.
Wählen Sie das Zertifikat aus, das Sie konfigurieren möchten.
Klicken Sie auf Datei > Neue Identitätseinstellung.
Geben Sie die URL ein und klicken Sie auf Hinzufügen.

Dadurch wird ein neuer Eintrag für die Identitätseinstellung in Ihrem Schlüsselbund erstellt, den Sie aktualisieren können.

Edge

Legen Sie die AutoSelectCertificateForUrls-Edge-Richtlinie gemäß der Anleitung in der Edge-Dokumentation fest.

Zertifikatbasierten Zugriff für Webanwendungen aktivieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.