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

Nutzerkonten mit dem produktübergreifenden Kontoschutz schützen

Wenn sich Nutzer in Ihrer App mit Google in ihren Konten anmelden können, können Sie die Sicherheit dieser Konten verbessern, indem Sie die Ereignisbenachrichtigungen zu Sicherheitsereignissen des produktübergreifenden Kontoschutzes abrufen und darauf reagieren.

Diese Benachrichtigungen informieren Sie über wichtige Änderungen an den Google-Konten Ihrer Nutzer, die oft auch Sicherheitsauswirkungen auf ihre Konten in Ihrer App haben können. Wenn beispielsweise das Google-Konto eines Nutzers gehackt wird, könnte dies über die Kontowiederherstellung per E‑Mail oder die Verwendung von Single Sign-on zu einer Kompromittierung des Kontos des Nutzers in Ihrer App führen.

Damit Sie das Risikopotenzial solcher Ereignisse minimieren können, sendet Google Ihren Diensten sogenannte Sicherheitshinweis-Tokens. Diese Tokens enthalten nur sehr wenige Informationen – nur die Art des Sicherheitsereignisses, den Zeitpunkt des Auftretens und die Kennung des betroffenen Nutzers. Sie können sie jedoch verwenden, um entsprechende Maßnahmen zu ergreifen. Wenn beispielsweise das Google-Konto eines Nutzers gehackt wurde, können Sie „Über Google anmelden“ für diesen Nutzer vorübergehend deaktivieren und verhindern, dass E-Mails zur Kontowiederherstellung an die Gmail-Adresse des Nutzers gesendet werden.

Der produktübergreifende Kontoschutz basiert auf dem RISC-Standard, der von der OpenID Foundation entwickelt wurde.

Übersicht

Wenn Sie den produktübergreifenden Kontoschutz für Ihre App oder Ihren Dienst verwenden möchten, müssen Sie die folgenden Aufgaben ausführen:

Richten Sie Ihr Projekt in der API Console ein.
Erstellen Sie einen Endpunkt für den Ereignisempfänger, an den Google Sicherheitshinweis-Tokens sendet. Dieser Endpunkt ist für die Validierung der empfangenen Tokens und die Reaktion auf Sicherheitsereignisse auf die von Ihnen gewählte Weise verantwortlich.
Registrieren Sie Ihren Endpunkt bei Google, um Sicherheitshinweis-Tokens zu erhalten.

Voraussetzungen

Sie erhalten nur Sicherheitshinweis-Tokens für Google-Nutzer, die Ihrem Dienst Zugriff auf ihre Profilinformationen oder E-Mail-Adressen gewährt haben. Sie erhalten diese Berechtigung, wenn Sie die Bereiche profile oder email anfordern. Die neueren SDKs für Über Google anmelden oder die älteren SDKs für Google Log-in fordern diese Bereiche standardmäßig an. Wenn Sie jedoch nicht die Standardeinstellungen verwenden oder direkt auf den OpenID Connect-Endpunkt von Google zugreifen, müssen Sie mindestens einen dieser Bereiche anfordern.

Projekt in der API Console einrichten

Bevor Sie Sicherheitshinweis-Tokens empfangen können, müssen Sie ein Dienstkonto erstellen und die RISC API in Ihrem API Console-Projekt aktivieren. Sie müssen dasselbe API Console-Projekt verwenden, das Sie für den Zugriff auf Google-Dienste wie Google Log-in in Ihrer App verwenden.

So erstellen Sie das Dienstkonto:

Öffnen Sie in der API Console die Seite Anmeldedaten. Wählen Sie bei Aufforderung das API Console-Projekt aus, das Sie für den Zugriff auf Google-Dienste in Ihrer App verwenden.
Klicken Sie auf Anmeldedaten erstellen > Dienstkonto.
Erstellen Sie ein neues Dienstkonto mit der Rolle „RISC Configuration Admin“ (roles/riscconfigs.admin). Folgen Sie dazu dieser Anleitung.
(Optional) Wenn Ihre Google Cloud-Organisation die Erstellung von Dienstkontoschlüsseln zulässt und Sie JWTs lokal signieren möchten, erstellen Sie einen Schlüssel für Ihr neu erstelltes Dienstkonto. Wählen Sie den Schlüsseltyp „JSON“ aus und klicken Sie dann auf Erstellen. Wenn der Schlüssel erstellt wird, laden Sie eine JSON-Datei mit den Anmeldedaten Ihres Dienstkontos herunter. Bewahren Sie diese Datei an einem sicheren Ort auf, der aber auch für den Endpunkt des Ereignisempfängers zugänglich ist.

Notieren Sie sich auf der Seite „Anmeldedaten“ Ihres Projekts auch die Client-IDs, die Sie für „Über Google anmelden“ oder „Google Log-in“ (alt) verwenden. In der Regel haben Sie für jede unterstützte Plattform eine Client-ID. Sie benötigen diese Client-IDs, um Sicherheitshinweis-Tokens zu validieren, wie im nächsten Abschnitt beschrieben.

So aktivieren Sie die RISC API:

Öffnen Sie in der API Console die Seite „RISC API“. Achten Sie darauf, dass das Projekt, das Sie für den Zugriff auf Google-Dienste verwenden, weiterhin ausgewählt ist.
Lesen Sie die RISC-Nutzungsbedingungen und machen Sie sich mit den Anforderungen vertraut.

Wenn Sie die API für ein Projekt aktivieren, das einer Organisation gehört, müssen Sie berechtigt sein, Ihre Organisation an die RISC-Nutzungsbedingungen zu binden.
Klicken Sie nur dann auf Aktivieren, wenn Sie den RISC-Nutzungsbedingungen zustimmen.

Ereignisempfänger-Endpunkt erstellen

Wenn Sie Benachrichtigungen zu Sicherheitsereignissen von Google erhalten möchten, erstellen Sie einen HTTPS-Endpunkt, der HTTPS-POST-Anfragen verarbeitet. Nachdem Sie diesen Endpunkt registriert haben (siehe unten), beginnt Google damit, kryptografisch signierte Strings, sogenannte Sicherheitshinweis-Tokens, an den Endpunkt zu senden. Sicherheitsereignis-Tokens sind signierte JWTs, die Informationen zu einem einzelnen sicherheitsrelevanten Ereignis enthalten.

Für jedes Sicherheitshinweis-Token, das Sie an Ihrem Endpunkt erhalten, müssen Sie das Token zuerst validieren und decodieren und dann den Sicherheitshinweis entsprechend Ihrem Dienst verarbeiten. Es ist unbedingt erforderlich, das Ereignistoken vor dem Decodieren zu validieren, um böswillige Angriffe zu verhindern. In den folgenden Abschnitten werden diese Aufgaben beschrieben:

1. Sicherheitsereignis-Token decodieren und validieren

Da Sicherheitshinweis-Tokens eine bestimmte Art von JWT sind, können Sie jede JWT-Bibliothek, z. B. eine der auf jwt.io aufgeführten, zum Decodieren und Validieren verwenden. Unabhängig davon, welche Bibliothek Sie verwenden, muss Ihr Tokenvalidierungscode Folgendes tun:

Rufen Sie die Aussteller-ID (issuer) und die Zertifikats-URI des Signaturschlüssels (jwks_uri) für den produktübergreifenden Kontoschutz aus dem RISC-Konfigurationsdokument von Google ab, das Sie unter https://accounts.google.com/.well-known/risc-configuration finden.
Rufen Sie mit der JWT-Bibliothek Ihrer Wahl die Signaturschlüssel-ID aus dem Header des Sicherheitshinweis-Tokens ab.
Rufen Sie aus dem Signaturschlüsselzertifikat-Dokument von Google den öffentlichen Schlüssel mit der Schlüssel-ID ab, die Sie im vorherigen Schritt erhalten haben. Wenn das Dokument keinen Schlüssel mit der gesuchten ID enthält, ist das Sicherheitshinweis-Token wahrscheinlich ungültig und Ihr Endpunkt sollte den HTTP-Fehler 400 zurückgeben.
Prüfen Sie mit der JWT-Bibliothek Ihrer Wahl Folgendes:
- Das Sicherheitshinweis-Token wird mit dem öffentlichen Schlüssel signiert, den Sie im vorherigen Schritt erhalten haben.
- Der aud-Anspruch des Tokens ist eine der Client-IDs Ihrer Apps.
- Die iss-Anforderung des Tokens stimmt mit der Aussteller-ID überein, die Sie aus dem RISC-Discovery-Dokument erhalten haben. Beachten Sie, dass Sie den Ablauf des Tokens (exp) nicht überprüfen müssen, da Sicherheitshinweis-Tokens historische Ereignisse darstellen und daher nicht ablaufen.

Beispiel:

Java

Mit java-jwt und jwks-rsa-java:

public DecodedJWT validateSecurityEventToken(String token) {
    DecodedJWT jwt = null;
    try {
        // In a real implementation, get these values from
        // https://accounts.google.com/.well-known/risc-configuration
        String issuer = "accounts.google.com";
        String jwksUri = "https://www.googleapis.com/oauth2/v3/certs";

        // Get the ID of the key used to sign the token.
        DecodedJWT unverifiedJwt = JWT.decode(token);
        String keyId = unverifiedJwt.getKeyId();

        // Get the public key from Google.
        JwkProvider googleCerts = new UrlJwkProvider(new URL(jwksUri), null, null);
        PublicKey publicKey = googleCerts.get(keyId).getPublicKey();

        // Verify and decode the token.
        Algorithm rsa = Algorithm.RSA256((RSAPublicKey) publicKey, null);
        JWTVerifier verifier = JWT.require(rsa)
                .withIssuer(issuer)
                // Get your apps' client IDs from the API console:
                // https://console.developers.google.com/apis/credentials?project=_
                .withAudience("123456789-abcedfgh.apps.googleusercontent.com",
                              "123456789-ijklmnop.apps.googleusercontent.com",
                              "123456789-qrstuvwx.apps.googleusercontent.com")
                .acceptLeeway(Long.MAX_VALUE)  // Don't check for expiration.
                .build();
        jwt = verifier.verify(token);
    } catch (JwkException e) {
        // Key not found. Return HTTP 400.
    } catch (InvalidClaimException e) {

    } catch (JWTDecodeException exception) {
        // Malformed token. Return HTTP 400.
    } catch (MalformedURLException e) {
        // Invalid JWKS URI.
    }
    return jwt;
}

Python

import json
import jwt       # pip install pyjwt
import requests  # pip install requests

def validate_security_token(token, client_ids):
    # Get Google's RISC configuration.
    risc_config_uri = 'https://accounts.google.com/.well-known/risc-configuration'
    risc_config = requests.get(risc_config_uri).json()

    # Get the public key used to sign the token.
    google_certs = requests.get(risc_config['jwks_uri']).json()
    jwt_header = jwt.get_unverified_header(token)
    key_id = jwt_header['kid']
    public_key = None
    for key in google_certs['keys']:
        if key['kid'] == key_id:
            public_key = jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps(key))
    if not public_key:
        raise Exception('Public key certificate not found.')
        # In this situation, return HTTP 400

    # Decode the token, validating its signature, audience, and issuer.
    try:
        token_data = jwt.decode(token, public_key, algorithms='RS256',
                                options={'verify_exp': False},
                                audience=client_ids, issuer=risc_config['issuer'])
    except:
        raise
        # Validation failed. Return HTTP 400.
    return token_data

# Get your apps' client IDs from the API console:
# https://console.developers.google.com/apis/credentials?project=_
client_ids = ['123456789-abcedfgh.apps.googleusercontent.com',
              '123456789-ijklmnop.apps.googleusercontent.com',
              '123456789-qrstuvwx.apps.googleusercontent.com']
token_data = validate_security_token(token, client_ids)

Wenn das Token gültig ist und erfolgreich decodiert wurde, wird der HTTP-Status 202 zurückgegeben. Behandeln Sie dann das durch das Token angegebene Sicherheitsereignis.

2. Sicherheitsereignisse verarbeiten

Nach der Decodierung sieht ein Sicherheitshinweis-Token in etwa so aus:

{
  "iss": "https://accounts.google.com/",
  "aud": "123456789-abcedfgh.apps.googleusercontent.com",
  "iat": 1508184845,
  "jti": "756E69717565206964656E746966696572",
  "events": {
    "https://schemas.openid.net/secevent/risc/event-type/account-disabled": {
      "subject": {
        "subject_type": "iss-sub",
        "iss": "https://accounts.google.com/",
        "sub": "7375626A656374"
      },
      "reason": "hijacking"
    }
  }
}

Die Anforderungen iss und aud geben den Aussteller des Tokens (Google) und den vorgesehenen Empfänger des Tokens (Ihren Dienst) an. Sie haben diese Anforderungen im vorherigen Schritt überprüft.

Der Anspruch jti ist ein String, der ein einzelnes Sicherheitsereignis identifiziert und für den Stream eindeutig ist. Mit dieser ID können Sie nachverfolgen, welche Sicherheitsereignisse Sie erhalten haben.

Der Anspruch events enthält Informationen zum Sicherheitsereignis, das das Token darstellt. Diese Anforderung ist eine Zuordnung von einer Ereignistyp-ID zu einer subject-Anforderung, die den Nutzer angibt, den dieses Ereignis betrifft, und zu allen zusätzlichen Details zum Ereignis, die möglicherweise verfügbar sind.

Die subject-Anforderung identifiziert einen bestimmten Nutzer mit seiner eindeutigen Google-Konto-ID (sub). Diese Google-Konto-ID ist dieselbe Kennung (sub), die in den JWT-ID-Tokens enthalten ist, die von der neueren „Über Google anmelden“-Bibliothek (JavaScript, HTML), der alten Google Log-in-Bibliothek oder OpenID Connect ausgestellt werden. Wenn der subject_type der Anforderung id_token_claims ist, kann sie auch ein email-Feld mit der E-Mail-Adresse des Nutzers enthalten.

Verwenden Sie die Informationen in der events-Anforderung, um die entsprechenden Maßnahmen für den Ereignistyp im Konto des angegebenen Nutzers zu ergreifen.

OAuth-Token-IDs

Bei OAuth-Ereignissen zu einzelnen Tokens enthält der Kennungstyp token_subject die folgenden Felder:

token_type: Nur refresh_token wird unterstützt.
token_identifier_alg: Mögliche Werte finden Sie in der Tabelle unten.
token: Siehe Tabelle unten.

token_identifier_alg	token
`prefix`	Die ersten 16 Zeichen des Tokens.
`hash_base64_sha512_sha512`	Der doppelte Hash des Tokens mit SHA-512.

Wenn Sie diese Ereignisse einbinden, sollten Sie Ihre Tokens anhand dieser möglichen Werte indexieren, damit sie schnell abgeglichen werden können, wenn das Ereignis empfangen wird.

Unterstützte Ereignistypen

Der produktübergreifende Kontoschutz unterstützt die folgenden Arten von Sicherheitshinweisen:

Ereignistyp	Attribute	Antworten
`https://schemas.openid.net/secevent/risc/event-type/sessions-revoked`		Erforderlich: Sichern Sie das Konto des Nutzers, indem Sie seine aktuell geöffneten Sitzungen beenden.
`https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked`		Erforderlich: Wenn das Token für Google Log-in bestimmt ist, beenden Sie die aktuell offenen Sitzungen. Außerdem solltest du dem Nutzer vorschlagen, eine alternative Anmeldemethode einzurichten. Empfohlen: Wenn das Token für den Zugriff auf andere Google APIs bestimmt ist, löschen Sie alle gespeicherten OAuth-Tokens des Nutzers.
`https://schemas.openid.net/secevent/oauth/event-type/token-revoked`	Informationen zu Token-IDs finden Sie im Abschnitt OAuth-Token-IDs.	Erforderlich: Wenn Sie das entsprechende Aktualisierungstoken speichern, löschen Sie es und fordern Sie den Nutzer auf, seine Einwilligung noch einmal zu erteilen, wenn ein Zugriffstoken benötigt wird.
`https://schemas.openid.net/secevent/risc/event-type/account-disabled`	`reason=hijacking`, `reason=bulk-account`	Erforderlich: Wenn das Konto aufgrund von `hijacking` deaktiviert wurde, müssen Sie es wieder sichern, indem Sie die aktuell offenen Sitzungen des Nutzers beenden. Vorschlag: Wenn das Konto aufgrund von `bulk-account` deaktiviert wurde, analysieren Sie die Aktivitäten des Nutzers in Ihrem Dienst und legen Sie entsprechende Folgemaßnahmen fest. Vorgeschlagen: Wenn kein Grund angegeben wurde, deaktivieren Sie „Über Google anmelden“ für den Nutzer und deaktivieren Sie die Kontowiederherstellung mit der E-Mail-Adresse, die mit dem Google-Konto des Nutzers verknüpft ist (normalerweise, aber nicht unbedingt, ein Gmail-Konto). Biete dem Nutzer eine alternative Anmeldemethode an.
`https://schemas.openid.net/secevent/risc/event-type/account-enabled`		Empfohlen: Aktivieren Sie „Über Google anmelden“ für den Nutzer wieder und aktivieren Sie die Kontowiederherstellung mit der E-Mail-Adresse des Google-Kontos des Nutzers wieder.
`https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required`		Empfohlen: Achten Sie auf verdächtige Aktivitäten in Ihrem Dienst und ergreifen Sie entsprechende Maßnahmen.
`https://schemas.openid.net/secevent/risc/event-type/verification`	state=`state`	Vorgeschlagen: Protokollieren Sie, dass ein Testtoken empfangen wurde.

Duplizierte und verpasste Ereignisse

Der produktübergreifende Kontoschutz versucht, Ereignisse, die vermutlich nicht zugestellt wurden, noch einmal zuzustellen. Daher kann es vorkommen, dass Sie dasselbe Ereignis mehrmals erhalten. Wenn dies zu wiederholten Aktionen führen könnte, die für Ihre Nutzer unpraktisch sind, sollten Sie die Ereignisse mit dem Anspruch jti (eine eindeutige Kennung für ein Ereignis) deduplizieren. Es gibt externe Tools wie Google Cloud Dataflow, mit denen Sie den Datenfluss zur Deduplizierung ausführen können.

Beachten Sie, dass Ereignisse mit einer begrenzten Anzahl von Wiederholungsversuchen zugestellt werden. Wenn Ihr Empfänger also über einen längeren Zeitraum nicht verfügbar ist, können einige Ereignisse dauerhaft verloren gehen.

Empfänger registrieren

Wenn Sie Sicherheitshinweise erhalten möchten, müssen Sie Ihren Empfängerendpunkt mit der RISC API registrieren. Aufrufe der RISC API müssen ein Autorisierungstoken enthalten.

Sie erhalten nur Sicherheitshinweise für die Nutzer Ihrer App. Daher müssen Sie in Ihrem GCP-Projekt einen OAuth-Zustimmungsbildschirm konfigurieren, bevor Sie die unten beschriebenen Schritte ausführen können.

1. Autorisierungstoken generieren

Sie können ein Autorisierungstoken für die RISC API entweder mit der Google Cloud CLI (gcloud) und der Identitätsübernahme des Dienstkontos generieren (empfohlen, wenn iam.disableServiceAccountKeyCreation erzwungen wird oder für die einmalige Einrichtung der Befehlszeile) oder indem Sie ein JWT lokal mit einem privaten Schlüssel des Dienstkontos signieren.

Option A: Kurzlebiges Zugriffstoken mit `gcloud` generieren (kein JSON-Schlüssel erforderlich)

Wenn Ihr Nutzerkonto die Rolle „Ersteller von Dienstkonto-Tokens“ (roles/iam.serviceAccountTokenCreator) für das Dienstkonto hat, können Sie ein kurzlebiges OAuth 2.0-Zugriffstoken mit dem erforderlichen RISC-Konfigurationsbereich direkt über Ihr Terminal erstellen:

AUTH_TOKEN=$(gcloud auth print-access-token \
  --impersonate-service-account=SERVICE_ACCOUNT_EMAIL \
  --scopes=https://www.googleapis.com/auth/risc.configuration.readwrite,https://www.googleapis.com/auth/risc.verify,https://www.googleapis.com/auth/risc.status.readwrite)

Weitere Informationen zu den verfügbaren OAuth 2.0-Bereichen für die RISC API finden Sie unter Zugriffstokenbereiche.

Option B: Selbst signiertes JWT mit einem Dienstkontoschlüssel erstellen

Alternativ können Sie ein Autorisierungstoken lokal ohne Netzwerk-Roundtrip generieren, indem Sie ein JWT mit den folgenden Anforderungen erstellen:

{
  "iss": SERVICE_ACCOUNT_EMAIL,
  "sub": SERVICE_ACCOUNT_EMAIL,
  "aud": "https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService",
  "iat": CURRENT_TIME,
  "exp": CURRENT_TIME + 3600
}

Signieren Sie das JWT mit dem privaten Schlüssel Ihres Dienstkontos. Sie finden ihn in der JSON-Datei, die Sie beim Erstellen des Dienstkontoschlüssels heruntergeladen haben.

Beispiel:

Java

Mit java-jwt und der Authentifizierungsbibliothek von Google:

public static String makeBearerToken() {
    String token = null;
    try {
        // Get signing key and client email address.
        FileInputStream is = new FileInputStream("your-service-account-credentials.json");
        ServiceAccountCredentials credentials =
               (ServiceAccountCredentials) GoogleCredentials.fromStream(is);
        PrivateKey privateKey = credentials.getPrivateKey();
        String keyId = credentials.getPrivateKeyId();
        String clientEmail = credentials.getClientEmail();

        // Token must expire in exactly one hour.
        Date issuedAt = new Date();
        Date expiresAt = new Date(issuedAt.getTime() + 3600000);

        // Create signed token.
        Algorithm rsaKey = Algorithm.RSA256(null, (RSAPrivateKey) privateKey);
        token = JWT.create()
                .withIssuer(clientEmail)
                .withSubject(clientEmail)
                .withAudience("https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService")
                .withIssuedAt(issuedAt)
                .withExpiresAt(expiresAt)
                .withKeyId(keyId)
                .sign(rsaKey);
    } catch (ClassCastException e) {
        // Credentials file doesn't contain a service account key.
    } catch (IOException e) {
        // Credentials file couldn't be loaded.
    }
    return token;
}

Python

import json
import time

import jwt  # pip install pyjwt

def make_bearer_token(credentials_file):
    with open(credentials_file) as service_json:
        service_account = json.load(service_json)
        issuer = service_account['client_email']
        subject = service_account['client_email']
        private_key_id = service_account['private_key_id']
        private_key = service_account['private_key']
    issued_at = int(time.time())
    expires_at = issued_at + 3600
    payload = {'iss': issuer,
               'sub': subject,
               'aud': 'https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService',
               'iat': issued_at,
               'exp': expires_at}
    encoded = jwt.encode(payload, private_key, algorithm='RS256',
                         headers={'kid': private_key_id})
    return encoded

auth_token = make_bearer_token('your-service-account-credentials.json')

Dieses Autorisierungstoken kann eine Stunde lang für RISC-API-Aufrufe verwendet werden. Wenn das Token abläuft, generieren Sie ein neues, um weiterhin RISC API-Aufrufe ausführen zu können.

2. RISC-Stream-Konfigurations-API aufrufen

Mit dem Autorisierungstoken können Sie die RISC API verwenden, um den Stream für Sicherheitsereignisse Ihres Projekts zu konfigurieren, einschließlich der Registrierung Ihres Empfängerendpunkts.

Senden Sie dazu eine HTTPS-POST-Anfrage an https://risc.googleapis.com/v1beta/stream:update und geben Sie Ihren Empfängerendpunkt und die Arten von Sicherheitsereignissen an, die Sie interessieren:

POST /v1beta/stream:update HTTP/1.1
Host: risc.googleapis.com
Authorization: Bearer AUTH_TOKEN

{
  "delivery": {
    "delivery_method":
      "https://schemas.openid.net/secevent/risc/delivery-method/push",
    "url": RECEIVER_ENDPOINT
  },
  "events_requested": [
    SECURITY_EVENT_TYPES
  ]
}

Beispiel:

Java

public static void configureEventStream(final String receiverEndpoint,
                                        final List<String> eventsRequested,
                                        String authToken) throws IOException {
    ObjectMapper jsonMapper = new ObjectMapper();
    String streamConfig = jsonMapper.writeValueAsString(new Object() {
        public Object delivery = new Object() {
            public String delivery_method =
                    "https://schemas.openid.net/secevent/risc/delivery-method/push";
            public String url = receiverEndpoint;
        };
        public List<String> events_requested = eventsRequested;
    });

    HttpPost updateRequest = new HttpPost("https://risc.googleapis.com/v1beta/stream:update");
    updateRequest.addHeader("Content-Type", "application/json");
    updateRequest.addHeader("Authorization", "Bearer " + authToken);
    updateRequest.setEntity(new StringEntity(streamConfig));

    HttpResponse updateResponse = new DefaultHttpClient().execute(updateRequest);
    Header[] responseContentTypeHeaders = updateResponse.getHeaders("Content-Type");
    StatusLine responseStatus = updateResponse.getStatusLine();
    int statusCode = responseStatus.getStatusCode();
    HttpEntity entity = updateResponse.getEntity();
    // Now handle response
}

// ...

configureEventStream(
        "https://your-service.example.com/security-event-receiver",
        Arrays.asList(
                "https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required",
                "https://schemas.openid.net/secevent/risc/event-type/account-disabled"),
        authToken);

Python

import requests

def configure_event_stream(auth_token, receiver_endpoint, events_requested):
    stream_update_endpoint = 'https://risc.googleapis.com/v1beta/stream:update'
    headers = {'Authorization': 'Bearer {}'.format(auth_token)}
    stream_cfg = {'delivery': {'delivery_method': 'https://schemas.openid.net/secevent/risc/delivery-method/push',
                               'url': receiver_endpoint},
                  'events_requested': events_requested}
    response = requests.post(stream_update_endpoint, json=stream_cfg, headers=headers)
    response.raise_for_status()  # Raise exception for unsuccessful requests

configure_event_stream(auth_token, 'https://your-service.example.com/security-event-receiver',
                       ['https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required',
                        'https://schemas.openid.net/secevent/risc/event-type/account-disabled'])

Wenn die Anfrage den HTTP-Statuscode 200 zurückgibt, wurde der Ereignisstream erfolgreich konfiguriert und Ihr Empfängerendpunkt sollte Sicherheitshinweis-Tokens empfangen. Im nächsten Abschnitt wird beschrieben, wie Sie Ihre Streamkonfiguration und Ihren Endpunkt testen können, um zu prüfen, ob alles ordnungsgemäß funktioniert.

Aktuelle Streamkonfiguration abrufen und aktualisieren

Wenn Sie die Streamkonfiguration später ändern möchten, können Sie eine autorisierte GET-Anfrage an https://risc.googleapis.com/v1beta/stream senden, um die aktuelle Streamkonfiguration abzurufen, den Antworttext zu ändern und die geänderte Konfiguration dann wie oben beschrieben per POST-Anfrage an https://risc.googleapis.com/v1beta/stream:update zurückzusenden.

Ereignisstream beenden und fortsetzen

Wenn Sie den Ereignisstream von Google beenden möchten, senden Sie eine autorisierte POST-Anfrage an https://risc.googleapis.com/v1beta/stream/status:update mit { "status": "disabled" } im Anfragetext. Während der Stream deaktiviert ist, sendet Google keine Ereignisse an Ihren Endpunkt und puffert keine Sicherheitsereignisse, wenn sie auftreten. Wenn Sie den Ereignisstream wieder aktivieren möchten, senden Sie einen POST-Befehl mit { "status": "enabled" } an denselben Endpunkt.

3. Optional: Streamkonfiguration testen

Sie können prüfen, ob Ihre Streamkonfiguration und der Empfängerendpunkt korrekt zusammenarbeiten, indem Sie ein Bestätigungstoken über Ihren Ereignisstream senden. Dieses Token kann einen eindeutigen String enthalten, mit dem Sie prüfen können, ob das Token an Ihrem Endpunkt empfangen wurde. Wenn Sie diesen Ablauf verwenden möchten, müssen Sie den Ereignistyp „https://schemas.openid.net/secevent/risc/event-type/verification“ abonnieren, wenn Sie Ihren Empfänger registrieren.

Wenn Sie ein Bestätigungstoken anfordern möchten, senden Sie eine autorisierte HTTPS-POST-Anfrage an https://risc.googleapis.com/v1beta/stream:verify. Geben Sie im Anfragetext einen Identifikationsstring an:

{
  "state": "ANYTHING"
}

Beispiel:

Java

public static void testEventStream(final String stateString,
                                   String authToken) throws IOException {
    ObjectMapper jsonMapper = new ObjectMapper();
    String json = jsonMapper.writeValueAsString(new Object() {
        public String state = stateString;
    });

    HttpPost updateRequest = new HttpPost("https://risc.googleapis.com/v1beta/stream:verify");
    updateRequest.addHeader("Content-Type", "application/json");
    updateRequest.addHeader("Authorization", "Bearer " + authToken);
    updateRequest.setEntity(new StringEntity(json));

    HttpResponse updateResponse = new DefaultHttpClient().execute(updateRequest);
    Header[] responseContentTypeHeaders = updateResponse.getHeaders("Content-Type");
    StatusLine responseStatus = updateResponse.getStatusLine();
    int statusCode = responseStatus.getStatusCode();
    HttpEntity entity = updateResponse.getEntity();
    // Now handle response
}

// ...

testEventStream("Test token requested at " + new Date().toString(), authToken);

Python

import requests
import time

def test_event_stream(auth_token, nonce):
    stream_verify_endpoint = 'https://risc.googleapis.com/v1beta/stream:verify'
    headers = {'Authorization': 'Bearer {}'.format(auth_token)}
    state = {'state': nonce}
    response = requests.post(stream_verify_endpoint, json=state, headers=headers)
    response.raise_for_status()  # Raise exception for unsuccessful requests

test_event_stream(auth_token, 'Test token requested at {}'.format(time.ctime()))

Wenn die Anfrage erfolgreich ist, wird das Bestätigungstoken an den von Ihnen registrierten Endpunkt gesendet. Wenn Ihr Endpunkt Bestätigungstokens beispielsweise einfach protokolliert, können Sie in Ihren Logs nachsehen, ob das Token empfangen wurde.

Fehlercode-Referenz

Die folgenden Fehler können von der RISC API zurückgegeben werden:

Fehlercode	Fehlermeldung	Vorgeschlagene Aktionen
400	Die Streamkonfiguration muss das Feld `$fieldname` enthalten.	Ihre Anfrage an den Endpunkt `https://risc.googleapis.com/v1beta/stream:update` ist ungültig oder kann nicht geparst werden. Geben Sie in Ihrer Anfrage `$fieldname` an.
401	Nicht autorisiert.	Fehler bei der Autorisierung Achten Sie darauf, dass Sie der Anfrage ein Autorisierungstoken angehängt haben und dass das Token gültig und nicht abgelaufen ist.
403	Der Lieferendpunkt muss eine HTTPS-URL sein.	Der Endpunkt für die Zustellung (d.h. der Endpunkt, an den RISC-Ereignisse gesendet werden sollen) muss HTTPS sein. Wir senden keine RISC-Ereignisse an HTTP-URLs.
403	Die vorhandene Stream-Konfiguration hat keine spezifikationskonforme Übermittlungsmethode für RISC.	Ihr Google Cloud-Projekt muss bereits eine RISC-Konfiguration haben. Wenn Sie Firebase verwenden und Google Log-in aktiviert haben, verwaltet Firebase RISC für Ihr Projekt. Sie können dann keine benutzerdefinierte Konfiguration erstellen. Wenn Sie Google Log-in nicht für Ihr Firebase-Projekt verwenden, deaktivieren Sie es und versuchen Sie nach einer Stunde noch einmal, das Projekt zu aktualisieren.
403	Das Projekt wurde nicht gefunden.	Achten Sie darauf, dass Sie das richtige Dienstkonto für das richtige Projekt verwenden. Möglicherweise verwenden Sie ein Dienstkonto, das mit einem gelöschten Projekt verknüpft ist. Informationen zum Aufrufen aller mit einem Projekt verknüpften Dienstkonten
403	Dienstkonto benötigt die Berechtigung, auf Ihre RISC-Konfiguration zuzugreifen	Rufen Sie die API Console Ihres Projekts auf und weisen Sie dem Dienstkonto, das die Aufrufe an Ihr Projekt sendet, die Rolle „RISC Configuration Admin“ (`roles/riscconfigs.admin`) zu. Folgen Sie dazu dieser Anleitung.
403	Stream Management APIs sollten nur von einem Dienstkonto aufgerufen werden.	Weitere Informationen dazu, wie Sie Google APIs mit einem Dienstkonto aufrufen können.
403	Der Lieferendpunkt gehört zu keiner der Domains Ihres Projekts.	Jedes Projekt hat eine Reihe von autorisierten Domains. Wenn Ihr Zustellungsendpunkt (also der Endpunkt, an den RISC-Ereignisse zugestellt werden sollen) nicht auf einer dieser Domains gehostet wird, müssen Sie die Domain des Endpunkts zu dieser Gruppe hinzufügen.
403	Wenn Sie diese API verwenden möchten, muss für Ihr Projekt mindestens ein OAuth-Client konfiguriert sein.	RISC funktioniert nur, wenn Sie eine App entwickeln, die Google Log-in unterstützt. Für diese Verbindung ist ein OAuth-Client erforderlich. Wenn Ihr Projekt keine OAuth-Clients hat, ist RISC wahrscheinlich nicht nützlich für Sie. Weitere Informationen zur Verwendung von OAuth für unsere APIs durch Google
403	Nicht unterstützter Status. Ungültiger Status	Derzeit werden nur die Streamstatus „`enabled`“ und „`disabled`“ unterstützt.
404	Das Projekt hat keine RISC-Konfiguration. Das Projekt hat keine RISC-Konfiguration. Der Status kann nicht aktualisiert werden.	Rufen Sie den Endpunkt `https://risc.googleapis.com/v1beta/stream:update` auf, um eine neue Streamkonfiguration zu erstellen.
4XX/5XX	Der Status kann nicht aktualisiert werden.	Weitere Informationen finden Sie in der detaillierten Fehlermeldung.

Zugriffstoken-Bereiche

Wenn Sie Zugriffstokens für die Authentifizierung bei der RISC API verwenden möchten, muss Ihre Anwendung die folgenden Bereiche anfordern:

Endpunkt	Einsatzbereich
`https://risc.googleapis.com/v1beta/stream/status`	`https://www.googleapis.com/auth/risc.status.readonly` ODER `https://www.googleapis.com/auth/risc.status.readwrite`
`https://risc.googleapis.com/v1beta/stream/status:update`	`https://www.googleapis.com/auth/risc.status.readwrite`
`https://risc.googleapis.com/v1beta/stream`	`https://www.googleapis.com/auth/risc.configuration.readonly` ODER `https://www.googleapis.com/auth/risc.configuration.readwrite`
`https://risc.googleapis.com/v1beta/stream:update`	`https://www.googleapis.com/auth/risc.configuration.readwrite`
`https://risc.googleapis.com/v1beta/stream:verify`	`https://www.googleapis.com/auth/risc.verify`

Benötigen Sie Hilfe?

Sehen Sie sich zuerst den Abschnitt Referenz zu Fehlercodes an. Wenn Sie weitere Fragen haben, posten Sie sie auf Stack Overflow mit dem Tag #SecEvents.

Nutzerkonten mit dem produktübergreifenden Kontoschutz schützen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Übersicht

Voraussetzungen

Projekt in der API Console einrichten

Ereignisempfänger-Endpunkt erstellen

1. Sicherheitsereignis-Token decodieren und validieren

Java

Python

2. Sicherheitsereignisse verarbeiten

OAuth-Token-IDs

Unterstützte Ereignistypen

Duplizierte und verpasste Ereignisse

Empfänger registrieren

1. Autorisierungstoken generieren

Option A: Kurzlebiges Zugriffstoken mit gcloud generieren (kein JSON-Schlüssel erforderlich)

Option B: Selbst signiertes JWT mit einem Dienstkontoschlüssel erstellen

Java

Python

2. RISC-Stream-Konfigurations-API aufrufen

Java

Python

Aktuelle Streamkonfiguration abrufen und aktualisieren

Ereignisstream beenden und fortsetzen

3. Optional: Streamkonfiguration testen

Java

Python

Fehlercode-Referenz

Zugriffstoken-Bereiche

Benötigen Sie Hilfe?

Nutzerkonten mit dem produktübergreifenden Kontoschutz schützen

Option A: Kurzlebiges Zugriffstoken mit `gcloud` generieren (kein JSON-Schlüssel erforderlich)