Schützen Sie Benutzerkonten mit kontenübergreifendem Schutz

Wenn sich Benutzer mit Ihrer App mit Google bei ihren Konten anmelden können, können Sie die Sicherheit der Konten dieser freigegebenen Benutzer verbessern, indem Sie die vom kontoübergreifenden Schutzdienst bereitgestellten Sicherheitsereignisbenachrichtigungen abhören und darauf reagieren.

Diese Benachrichtigungen weisen Sie auf wichtige Änderungen an den Google-Konten Ihrer Nutzer hin, die häufig auch Auswirkungen auf die Sicherheit ihrer Konten mit Ihrer App haben können. Wenn beispielsweise das Google-Konto eines Benutzers entführt wird, kann dies möglicherweise zu einer Beeinträchtigung des Benutzerkontos bei Ihrer App durch die Wiederherstellung eines E-Mail-Kontos oder die Verwendung der einmaligen Anmeldung führen.

Um das Risikopotenzial solcher Ereignisse zu verringern, sendet Google Ihre Serviceobjekte, die als Sicherheitsereignistoken bezeichnet werden. Diese Token enthalten nur sehr wenige Informationen - nur die Art des Sicherheitsereignisses und den Zeitpunkt seines Auftretens sowie die Kennung des betroffenen Benutzers -, aber Sie können sie verwenden, um als Reaktion darauf geeignete Maßnahmen zu ergreifen. Wenn beispielsweise das Google-Konto eines Nutzers kompromittiert wurde, können Sie die Google-Anmeldung für diesen Nutzer vorübergehend deaktivieren und verhindern, dass E-Mails zur Kontowiederherstellung an die Google Mail-Adresse des Nutzers gesendet werden.

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

Überblick

Um den kontenübergreifenden Schutz mit Ihrer App oder Ihrem Dienst zu verwenden, müssen Sie die folgenden Aufgaben ausführen:

  1. Richten Sie Ihr Projekt im API Console ein.

  2. Erstellen Sie einen Ereignisempfänger-Endpunkt, an den Google Sicherheitsereignistoken sendet. Dieser Endpunkt ist dafür verantwortlich, die empfangenen Token zu validieren und dann auf die von Ihnen gewählte Weise auf Sicherheitsereignisse zu reagieren.

  3. Registrieren Sie Ihren Endpunkt bei Google, um Sicherheitsereignistoken zu erhalten.

Voraussetzung

Sie erhalten nur Sicherheitsereignistoken für Google-Nutzer, die Ihrem Dienst die Berechtigung zum Zugriff auf ihre Profilinformationen oder E-Mail-Adressen erteilt haben. Sie erhalten diese Berechtigung, indem Sie die profile oder email Bereiche anfordern. Die Google Sign-in- SDKs fordern diese Bereiche standardmäßig an. Wenn Sie jedoch nicht die Standardeinstellungen verwenden oder direkt auf den OpenID Connect-Endpunkt von Google zugreifen, stellen Sie sicher, dass Sie mindestens einen dieser Bereiche anfordern.

Richten Sie ein Projekt in API Console ein

Bevor Sie mit dem Empfang von Sicherheitsereignistoken beginnen 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, mit dem Sie in Ihrer App auf Google-Dienste wie Google Sign-in zugreifen.

So erstellen Sie das Dienstkonto:

  1. Öffnen Sie die API Console Credentials page . Wenn Sie dazu aufgefordert werden, wählen Sie das Projekt API Console aus, mit dem Sie in Ihrer App auf Google-Dienste zugreifen.

  2. Klicken Sie auf Anmeldeinformationen erstellen> Dienstkontoschlüssel .

  3. Erstellen Sie ein neues Dienstkonto mit der Editor-Rolle.

    Wählen Sie den JSON-Schlüsseltyp und klicken Sie dann auf Erstellen . Wenn der Schlüssel erstellt wird, laden Sie eine JSON-Datei herunter, die Ihre Anmeldeinformationen für das Dienstkonto enthält. Bewahren Sie diese Datei an einem sicheren Ort auf, aber auch für Ihren Ereignisempfänger-Endpunkt zugänglich.

Notieren Sie sich auf der Seite mit den Anmeldeinformationen Ihres Projekts auch die Client-IDs, die Sie für die Google-Anmeldung verwenden. In der Regel haben Sie eine Client-ID für jede von Ihnen unterstützte Plattform. Sie benötigen diese Client-IDs, um Sicherheitsereignistoken zu validieren, wie im nächsten Abschnitt beschrieben.

So aktivieren Sie die RISC-API:

  1. Öffnen Sie die RISC-API-Seite in API Console. Stellen Sie sicher, dass das Projekt, mit dem Sie auf Google-Dienste zugreifen, weiterhin ausgewählt ist.

  2. Lesen Sie die RISC-Bedingungen und stellen Sie sicher, dass Sie die Anforderungen verstehen.

    Wenn Sie die API für ein Projekt aktivieren, das einer Organisation gehört, stellen Sie sicher, dass Sie berechtigt sind, Ihre Organisation an die RISC-Bedingungen zu binden.

  3. Klicken Sie nur auf Aktivieren , wenn Sie den RISC-Bedingungen zustimmen.

Erstellen Sie einen Endpunkt für den Ereignisempfänger

Um Sicherheitsereignisbenachrichtigungen von Google zu erhalten, erstellen Sie einen HTTPS-Endpunkt, der HTTPS-POST-Anforderungen verarbeitet. Nachdem Sie diesen Endpunkt registriert haben (siehe unten), sendet Google kryptografisch signierte Zeichenfolgen, sogenannte Sicherheitsereignistoken, an den Endpunkt. Sicherheitsereignistoken sind signierte JWTs, die Informationen zu einem einzelnen sicherheitsrelevanten Ereignis enthalten.

Überprüfen und dekodieren Sie für jedes Sicherheitsereignistoken, das Sie an Ihrem Endpunkt erhalten, zuerst das Token und behandeln Sie dann das Sicherheitsereignis entsprechend Ihrem Dienst. In den folgenden Abschnitten werden diese Aufgaben beschrieben:

1. Dekodieren und validieren Sie das Sicherheitsereignistoken

Da es sich bei Sicherheitsereignistoken um eine bestimmte Art von JWT handelt, können Sie jede JWT-Bibliothek verwenden, z. B. eine auf jwt.io aufgeführte , um sie zu dekodieren und zu validieren. Unabhängig davon, welche Bibliothek Sie verwenden, muss Ihr Token-Validierungscode Folgendes tun:

  1. jwks_uri ausstellerübergreifende jwks_uri ( issuer ) und den Signaturschlüssel-URI ( jwks_uri ) aus dem RISC-Konfigurationsdokument von Google ab, das Sie unter https://accounts.google.com/.well-known/risc-configuration .
  2. Rufen Sie mithilfe der JWT-Bibliothek Ihrer Wahl die Signaturschlüssel-ID aus dem Header des Sicherheitsereignistokens ab.
  3. Rufen Sie aus dem Dokument mit dem Signaturschlüsselzertifikat 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 von Ihnen gesuchten ID enthält, ist das Token für Sicherheitsereignisse wahrscheinlich ungültig, und Ihr Endpunkt sollte den HTTP-Fehler 400 zurückgeben.
  4. Überprüfen Sie mithilfe der JWT-Bibliothek Ihrer Wahl Folgendes:
    • Das Sicherheitsereignistoken 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.
    • Der iss Anspruch des Tokens stimmt mit der Issuer-ID überein, die Sie aus dem RISC-Erkennungsdokument erhalten haben. Beachten Sie, dass Sie den Ablauf ( exp ) des Tokens nicht überprüfen müssen, da Sicherheitsereignistoken historische Ereignisse darstellen und als solche nicht ablaufen.

Beispielsweise:

Java

Verwenden von 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 dekodiert wurde, geben Sie den HTTP-Status 202 zurück. Behandeln Sie dann das vom Token angegebene Sicherheitsereignis.

2. Behandeln Sie Sicherheitsereignisse

Beim Dekodieren sieht ein Sicherheitsereignistoken wie folgt 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 Ansprüche iss und aud geben den Aussteller des Tokens (Google) und den beabsichtigten Empfänger des Tokens (Ihren Dienst) an. Sie haben diese Behauptungen im vorherigen Schritt überprüft.

Der jti Anspruch ist eine Zeichenfolge, die ein einzelnes Sicherheitsereignis identifiziert und für den Stream eindeutig ist. Mit dieser Kennung können Sie verfolgen, welche Sicherheitsereignisse Sie erhalten haben.

Der events enthält Informationen zu dem Sicherheitsereignis, das das Token darstellt. Dieser Anspruch ist eine Abbildung von einer Ereignistyp - Kennung zu einem subject Ansprüchen, die den Benutzer dieses Ereignis betreffen, und auf zusätzliche Informationen über das Ereignis angibt , die verfügbar sein könnte.

Der subject Anspruch identifiziert einen bestimmten Nutzer mit der eindeutigen Google-Konto-ID ( sub ) des Nutzers. Diese ID entspricht der ID, die in den von Google Sign-in erstellten ID-Token enthalten ist. Wenn der subject_type des Anspruchs id_token_claims , kann er auch ein email Feld mit der E-Mail-Adresse des Benutzers enthalten.

Verwenden Sie die Informationen im events , um geeignete Maßnahmen für den Ereignistyp im Konto des angegebenen Benutzers zu ergreifen.

Unterstützte Ereignistypen

Der kontenübergreifende Schutz unterstützt die folgenden Arten von Sicherheitsereignissen:

Ereignistyp Attribute Wie soll man antworten
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked Erforderlich : Sichern Sie das Benutzerkonto erneut, indem Sie die aktuell geöffneten Sitzungen beenden.
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

Erforderlich : Wenn das Token für die Google-Anmeldung bestimmt ist, beenden Sie die derzeit geöffneten Sitzungen. Darüber hinaus möchten Sie dem Benutzer möglicherweise vorschlagen, eine alternative Anmeldemethode einzurichten.

Vorgeschlagen : Wenn das Token für den Zugriff auf andere Google-APIs vorgesehen ist, löschen Sie alle von Ihnen gespeicherten OAuth-Token des Benutzers.

https://schemas.openid.net/secevent/risc/event-type/account-disabled reason=hijacking ,
reason=bulk-account

Erforderlich : Wenn der Grund für die Deaktivierung des Kontos die hijacking , sichern Sie das Konto des Benutzers erneut, indem Sie die aktuell geöffneten Sitzungen beenden.

Vorgeschlagen : Wenn der Grund, warum das Konto deaktiviert wurde, ein bulk-account , analysieren Sie die Aktivität des Benutzers in Ihrem Dienst und ermitteln Sie geeignete Folgemaßnahmen.

Vorgeschlagen : Wenn kein Grund angegeben wurde, deaktivieren Sie die Google-Anmeldung für den Benutzer und die Kontowiederherstellung mithilfe der E-Mail-Adresse, die dem Google-Konto des Benutzers zugeordnet ist (normalerweise, aber nicht unbedingt, ein Google Mail-Konto). Bieten Sie dem Benutzer eine alternative Anmeldemethode an.

https://schemas.openid.net/secevent/risc/event-type/account-enabled Vorgeschlagen : Aktivieren Sie die Google-Anmeldung für den Benutzer erneut und aktivieren Sie die Kontowiederherstellung mit der E-Mail-Adresse des Google-Kontos des Benutzers.
https://schemas.openid.net/secevent/risc/event-type/account-purged Vorgeschlagen : Löschen Sie das Benutzerkonto oder stellen Sie ihm eine alternative Anmeldemethode zur Verfügung.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Vorgeschlagen : Achten Sie auf verdächtige Aktivitäten in Ihrem Dienst und ergreifen Sie geeignete Maßnahmen.
https://schemas.openid.net/secevent/risc/event-type/verification Zustand = state Vorgeschlagen : Protokollieren Sie, dass ein Testtoken empfangen wurde.

Doppelte und verpasste Ereignisse

Der kontenübergreifende Schutz versucht, Ereignisse erneut zuzustellen, von denen er glaubt, dass sie nicht zugestellt wurden. Daher erhalten Sie manchmal dasselbe Ereignis mehrmals. Wenn dies zu wiederholten Aktionen führen kann, die Ihre Benutzer jti , sollten Sie den jti Anspruch (eine eindeutige Kennung für ein Ereignis) verwenden, um die Ereignisse zu deaktivieren. Es gibt externe Tools wie Google Cloud Dataflow , mit denen Sie den De-Dup-Datenfluss ausführen können.

Beachten Sie, dass Ereignisse mit begrenzten Wiederholungsversuchen ausgeliefert werden. Wenn Ihr Empfänger längere Zeit nicht verfügbar ist, können Sie einige Ereignisse dauerhaft verpassen.

Registrieren Sie Ihren Empfänger

Registrieren Sie Ihren Empfängerendpunkt mithilfe der RISC-API, um Sicherheitsereignisse zu empfangen. Aufrufe der RISC-API müssen von einem Autorisierungstoken begleitet sein.

Sie erhalten Sicherheitsereignisse nur für die Benutzer Ihrer App. Daher muss in Ihrem GCP-Projekt ein OAuth-Zustimmungsbildschirm als Voraussetzung für die unten beschriebenen Schritte konfiguriert sein .

1. Generieren Sie ein Autorisierungstoken

Erstellen Sie ein JWT mit den folgenden Ansprüchen, um ein Autorisierungstoken für die RISC-API zu generieren:

{
  "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, den Sie in der JSON-Datei finden, die Sie beim Erstellen des Dienstkontoschlüssels heruntergeladen haben.

Beispielsweise:

Java

Verwenden von Java-JWT und der Auth-Bibliothek 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')

Mit diesem Autorisierungstoken können RISC-API-Aufrufe für eine Stunde ausgeführt werden. Wenn das Token abläuft, generieren Sie ein neues, um weiterhin RISC-API-Aufrufe durchzuführen.

2. Rufen Sie die RISC-Stream-Konfigurations-API auf

Nachdem Sie über ein Autorisierungstoken verfügen, können Sie mithilfe der RISC-API den Sicherheitsereignisstrom Ihres Projekts konfigurieren, einschließlich der Registrierung Ihres Empfängerendpunkts.

Stellen 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, an denen Sie interessiert sind:

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

Beispielsweise:

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 Anforderung HTTP 200 zurückgibt, wurde der Ereignisstrom erfolgreich konfiguriert und Ihr Empfängerendpunkt sollte mit dem Empfang von Sicherheitsereignistoken beginnen. Im nächsten Abschnitt wird beschrieben, wie Sie Ihre Stream-Konfiguration und Ihren Endpunkt testen können, um sicherzustellen, dass alles ordnungsgemäß zusammenarbeitet.

Holen Sie sich Ihre aktuelle Stream-Konfiguration und aktualisieren Sie sie

Wenn Sie in Zukunft Ihre Stream-Konfiguration ändern möchten, können Sie dies tun, indem Sie eine autorisierte GET-Anfrage an https://risc.googleapis.com/v1beta/stream , um die aktuelle Stream-Konfiguration abzurufen und den Antworttext zu ändern und dann die geänderte Konfiguration wie oben beschrieben an https://risc.googleapis.com/v1beta/stream:update zurücksenden.

Stoppen Sie den Ereignisstrom und setzen Sie ihn fort

Wenn Sie den Ereignisstrom von Google jemals stoppen müssen, 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. Um den Ereignisstrom wieder zu aktivieren, POST { "status": "enabled" } an denselben Endpunkt.

3. Optional: Testen Sie Ihre Stream-Konfiguration

Sie können überprüfen, ob Ihre Stream-Konfiguration und Ihr Empfängerendpunkt ordnungsgemäß zusammenarbeiten, indem Sie ein Bestätigungstoken über Ihren Ereignis-Stream senden. Dieses Token kann eine eindeutige Zeichenfolge enthalten, mit der Sie überprüfen können, ob das Token an Ihrem Endpunkt empfangen wurde.

Um ein Bestätigungstoken anzufordern, https://risc.googleapis.com/v1beta/stream:verify eine autorisierte HTTPS-POST-Anforderung an https://risc.googleapis.com/v1beta/stream:verify . Geben Sie im Hauptteil der Anforderung eine identifizierende Zeichenfolge an:

{
  "state": "ANYTHING"
}

Beispielsweise:

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 Anforderung erfolgreich ist, wird das Bestätigungstoken an den von Ihnen registrierten Endpunkt gesendet. Wenn Ihr Endpunkt beispielsweise Verifizierungstoken durch einfaches Protokollieren verarbeitet, können Sie Ihre Protokolle überprüfen, um zu bestätigen, dass das Token empfangen wurde.

Fehlercode-Referenz

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

Fehlercode Fehlermeldung Vorgeschlagene Handlungen
400 Die Stream-Konfiguration muss das Feld $ fieldname enthalten. Ihre Anfrage an den Endpunkt https://risc.googleapis.com/v1beta/stream:update ist ungültig oder kann nicht analysiert werden. Bitte geben Sie $ fieldname in Ihre Anfrage ein.
401 Nicht autorisiert. Autorisation fehlgeschlagen. Stellen Sie sicher, dass Sie der Anforderung ein Autorisierungstoken beigefügt haben und dass das Token gültig ist und nicht abgelaufen ist.
403 Der Übermittlungsendpunkt muss eine HTTPS-URL sein. Ihr Übermittlungsendpunkt (dh der Endpunkt, an den RISC-Ereignisse voraussichtlich übermittelt werden) muss HTTPS sein. Wir senden keine RISC-Ereignisse an HTTP-URLs.
403 Die vorhandene Stream-Konfiguration verfügt nicht über eine spezifikationskonforme Übermittlungsmethode für RISC. Ihr Google Cloud-Projekt muss bereits über eine RISC-Konfiguration verfügen. Wenn Sie Firebase verwenden und Google Sign-In aktiviert haben, verwaltet Firebase RISC für Ihr Projekt. Sie können keine benutzerdefinierte Konfiguration erstellen. Wenn Sie Google Sign-In nicht für Ihr Firebase-Projekt verwenden, deaktivieren Sie es und versuchen Sie nach einer Stunde erneut, das Update durchzuführen.
403 Projekt konnte nicht gefunden werden. Stellen Sie sicher, dass Sie das richtige Dienstkonto für das richtige Projekt verwenden. Möglicherweise verwenden Sie ein Dienstkonto, das einem gelöschten Projekt zugeordnet ist. Erfahren Sie, wie Sie alle mit einem Projekt verknüpften Dienstkonten anzeigen .
403 Das Dienstkonto muss über Editorberechtigungen in Ihrem Projekt verfügen. Gehen Sie zur Google Cloud Platform-Konsole Ihres Projekts und erteilen Sie dem Dienstkonto, das dem Anrufeditor / Eigentümer die Berechtigung für Ihr Projekt erteilt, indem Sie diese Anweisungen befolgen .
403 Stream-Management-APIs sollten nur von einem Dienstkonto aufgerufen werden. Hier finden Sie weitere Informationen dazu, wie Sie Google APIs mit einem Dienstkonto aufrufen können .
403 Der Übermittlungsendpunkt gehört zu keiner der Domänen Ihres Projekts. Jedes Projekt verfügt über eine Reihe autorisierter Domänen. Wenn Ihr Übermittlungsendpunkt (dh der Endpunkt, an den RISC-Ereignisse voraussichtlich übermittelt werden) nicht auf einem dieser Endpunkte gehostet wird, müssen Sie diesem Satz die Domäne des Endpunkts hinzufügen.
403 Um diese API verwenden zu können, muss in Ihrem Projekt mindestens ein OAuth-Client konfiguriert sein. RISC funktioniert nur, wenn Sie eine App erstellen, die Google Sign In unterstützt . Diese Verbindung erfordert einen OAuth-Client. Wenn Ihr Projekt keine OAuth-Clients hat, ist RISC wahrscheinlich nicht für Sie nützlich. Erfahren Sie mehr über die Verwendung von OAuth durch Google für unsere APIs .
403

Nicht unterstützter Status.

Ungültiger Status.

Derzeit unterstützen wir nur die Stream-Status " enabled " und " disabled ".
404

Das Projekt hat keine RISC-Konfiguration.

Das Projekt hat keine vorhandene RISC-Konfiguration und kann den Status nicht aktualisieren.

Rufen Sie den Endpunkt https://risc.googleapis.com/v1beta/stream:update auf, um eine neue Stream-Konfiguration zu erstellen.
4XX / 5XX Status kann nicht aktualisiert werden. Überprüfen Sie die detaillierte Fehlermeldung auf weitere Informationen.

Zugriff auf Token-Bereiche

Wenn Sie sich für die Verwendung von Zugriffstoken zur Authentifizierung bei der RISC-API entscheiden, müssen Ihre Bereiche folgende Bereiche anfordern:

Endpunkt Umfang
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

Brauchen Sie Hilfe?

Schauen Sie sich zunächst unseren Referenzabschnitt zum Fehlercode an . Wenn Sie noch Fragen haben, veröffentlichen Sie diese mit dem Tag #SecEvents im Stapelüberlauf .