Nutzerkonten mit kontoübergreifendem Schutz schützen

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Wenn sich Nutzer in Ihrer App über Google in ihren Konten anmelden können, lässt sich die Sicherheit dieser freigegebenen Nutzer verbessern. Dafür hören Sie die vom Sicherheitsdienst bereitgestellten Sicherheitsbenachrichtigungen zu und reagieren darauf.

Mit diesen Benachrichtigungen werden Sie über wichtige Änderungen an den Google-Konten Ihrer Nutzer informiert. Dies kann häufig auch Auswirkungen auf die Sicherheit der Konten Ihrer Nutzer haben, z. B. weil ein gehacktes Google-Konto zu einem Missbrauch des Nutzerkontos durch Ihre E-Mail-Adresse oder zur Verwendung der Einmalanmeldung (SSO) führen könnte.

Google sendet Ihre Dienstobjekte, sogenannte Sicherheitsereignis-Tokens, um das Risikopotenzial solcher Ereignisse zu minimieren. Diese Tokens enthalten nur sehr wenige Informationen – nur die Art des Sicherheitsereignisses und wann es aufgetreten ist und die ID des betroffenen Nutzers, aber Sie können sie verwenden, um entsprechende Maßnahmen zu ergreifen. Wenn beispielsweise das Google-Konto eines Nutzers manipuliert wurde, könnten 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 kontoübergreifende Schutz basiert auf dem RISC-Standard, der von der OpenID Foundation entwickelt wurde.

Übersicht

Führen Sie die folgenden Aufgaben aus, um den kontoübergreifenden Schutz mit Ihrer Anwendung oder Ihrem Dienst zu verwenden:

  1. Richten Sie Ihr Projekt im API Consoleein.

  2. Erstellen Sie einen Ereignisempfängerendpunkt, an den Google Sicherheitsereignis-Tokens sendet. Dieser Endpunkt ist dafür verantwortlich, die empfangenen Tokens zu validieren und dann auf Sicherheitsereignisse in beliebiger Weise zu reagieren.

  3. Registrieren Sie Ihren Endpunkt bei Google, um Sicherheitsereignis-Tokens zu erhalten.

Voraussetzung

Sie erhalten Tokens für Sicherheitsereignisse nur für Google-Nutzer, die Ihrem Dienst die Berechtigung zum Zugriff auf ihre Profilinformationen oder E-Mail-Adressen erteilt haben. Sie erhalten diese Berechtigung, wenn Sie die Bereiche profile oder email anfordern. Diese werden von den neueren Über Google anmelden- oder der alten Google Log-in-SDKs standardmäßig angefordert. 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 Consoleeinrichten

Bevor Sie Sicherheitsereignis-Tokens erhalten können, müssen Sie ein Dienstkonto erstellen und die RISC API in IhremAPI Console -Projekt aktivieren. Sie müssen in Ihrer App dasselbeAPI Console Projekt verwenden, mit dem Sie auf Google-Dienste wie Google Log-in zugreifen.

So erstellen Sie das Dienstkonto:

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

  2. Klicken Sie auf Anmeldedaten erstellen > Dienstkonto.

  3. Erstellen Sie ein neues Dienstkonto mit der Rolle „Bearbeiter“.

  4. Erstellen Sie einen Schlüssel für das neu erstellte Dienstkonto. Wählen Sie den JSON-Schlüsseltyp aus und klicken Sie auf Erstellen. Laden Sie dann eine JSON-Datei mit den Anmeldedaten Ihres Dienstkontos herunter. Speichern Sie diese Datei an einem sicheren Ort, auf den auch der Endpunkt des Ereignisempfängers zugreifen kann.

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. Normalerweise hast du für jede unterstützte Plattform eine Client-ID. Sie benötigen diese Client-IDs, um Sicherheitsereignis-Tokens zu validieren, wie im nächsten Abschnitt beschrieben.

So aktivieren Sie die RISC API:

  1. Öffnen Sie in derAPI Consoledie RISC API-Seite. Achten Sie darauf, dass das Projekt, mit dem Sie auf Google-Dienste zugreifen, weiterhin ausgewählt ist.

  2. 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, prüfen Sie, ob Sie berechtigt sind, Ihre Organisation an die RISC-Nutzungsbedingungen zu binden.

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

Ereignisempfängerendpunkt 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, kryptografisch signierte Strings, die als Sicherheitsereignis-Tokens bezeichnet werden, an den Endpunkt zu senden. Sicherheitsereignis-Tokens sind signierte JWTs, die Informationen zu einem einzelnen sicherheitsbezogenen Ereignis enthalten.

Prüfen und decodieren Sie für jedes Sicherheitsereignis-Token, das Sie an Ihrem Endpunkt erhalten, zuerst das Sicherheitsereignis, das für Ihren Dienst geeignet ist. Es ist unerlässlich, das Ereignistoken vor der Decodierung zu validieren, um böswillige Angriffe durch böswillige Akteure zu verhindern. In den folgenden Abschnitten werden diese Aufgaben beschrieben:

1. Sicherheitsereignis-Token decodieren und validieren

Da Sicherheitsereignis-Tokens eine bestimmte Art von JWT sind, können Sie eine beliebige JWT-Bibliothek, z. B. eine auf jwt.io aufgelistete JWT, zur Decodierung und Validierung verwenden. Unabhängig davon, welche Bibliothek Sie verwenden, muss Ihr Token-Validierungscode Folgendes tun:

  1. Rufen Sie die ID des kontoübergreifenden Ausstellers (issuer) und den Signierschlüssel-URI (jwks_uri) aus dem RISC-Konfigurationsdokument von Google ab. Sie finden ihn unter https://accounts.google.com/.well-known/risc-configuration.
  2. Verwenden Sie die JWT-Bibliothek Ihrer Wahl, um die Signaturschlüssel-ID aus dem Header des Sicherheitsereignis-Tokens abzurufen.
  3. Rufen Sie im Dokument mit dem Signaturschlüssel 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 Sicherheitsereignis-Token wahrscheinlich ungültig und Ihr Endpunkt sollte den HTTP-Fehler 400 zurückgeben.
  4. Prüfen Sie mit der JWT-Bibliothek Ihrer Wahl Folgendes:
    • Das Sicherheitsereignis-Token wird mit dem öffentlichen Schlüssel signiert, den Sie im vorherigen Schritt erhalten haben.
    • Die aud-Anforderung des Tokens ist eine Ihrer Client-IDs.
    • Die iss-Anforderung des Tokens stimmt mit der Aussteller-ID überein, die Sie im RISC-Discovery-Dokument erhalten haben. Hinweis: Sie müssen das Ablaufdatum (exp) des Tokens nicht überprüfen, da die Sicherheitsereignis-Tokens historische Ereignisse darstellen. Daher laufen sie nicht ab.

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 und erfolgreich decodiert wurde, wird der HTTP-Status 202 zurückgegeben. Verarbeiten Sie dann das durch das Token angegebene Sicherheitsereignis.

2. Sicherheitshinweise verarbeiten

Bei der Decodierung sieht ein Sicherheitsereignis-Token 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 beabsichtigten Empfänger (Ihr Dienst) des Tokens an. Du hast diese Ansprüche im vorherigen Schritt bestätigt.

Die jti-Anforderung ist ein String, der ein einzelnes Sicherheitsereignis identifiziert und für den Stream eindeutig ist. Mit dieser Kennung können Sie verfolgen, welche Sicherheitsereignisse Sie erhalten haben.

Die Anforderung events enthält Informationen zum Sicherheitsereignis, das das Token darstellt. Dieser Anspruch ist eine Zuordnung von einer Ereignistypkennung zu einem subject-Anspruch, der den Nutzer angibt, auf den sich dieses Ereignis bezieht, sowie alle zusätzlichen Details zum Ereignis, die möglicherweise verfügbar sind.

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

Verwende die Informationen in der events-Anforderung, um für den Ereignistyp im angegebenen Nutzerkonto entsprechende Maßnahmen zu ergreifen.

OAuth-Token-IDs

Bei OAuth-Ereignissen für einzelne Tokens enthält der Kennzeichnungstyp Token-Betreff 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 Token
prefix Die ersten 16 Zeichen des Tokens.
hash_base64_sha512_sha512 Der doppelte Hash des Tokens mit SHA-512.

Bei der Einbindung dieser Ereignisse wird empfohlen, Ihre Tokens anhand dieser möglichen Werte zu indexieren, damit beim Empfang des Ereignisses schnell eine Übereinstimmung gefunden wird.

Unterstützte Ereignistypen

Der kontoübergreifende Schutz 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 noch einmal, indem Sie seine derzeit 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, beende die gerade geöffneten Sitzungen. Außerdem kannst du dem Nutzer vorschlagen, eine alternative Anmeldemethode einzurichten.

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

https://schemas.openid.net/secevent/oauth/event-type/token-revoked Weitere 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 nächste Einwilligung einzuholen.

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

Erforderlich: Wenn das Konto hijacking deaktiviert war, schütze das Konto des Nutzers wieder, indem du seine derzeit geöffneten Sitzungen beendest.

Vorgeschlagen: Wenn der Grund für die Deaktivierung des Kontos bulk-account war, analysiere die Aktivitäten des Nutzers in deinem Dienst und ermittle die entsprechenden Folgeaktionen.

Vorgeschlagen: Wenn kein Grund angegeben wurde, deaktiviere Google Log-in für den Nutzer und deaktiviere die Kontowiederherstellung mithilfe der E-Mail-Adresse, die mit dem Google-Konto des Nutzers verknüpft ist (in der Regel, aber nicht unbedingt ein Gmail-Konto). Bieten Sie dem Nutzer eine alternative Anmeldemethode an.

https://schemas.openid.net/secevent/risc/event-type/account-enabled Empfohlen: Google Log-in für den Nutzer und die Kontowiederherstellung mit der E-Mail-Adresse des Google-Kontos des Nutzers wieder aktivieren.
https://schemas.openid.net/secevent/risc/event-type/account-purged Empfohlen: Lösche das Konto des Nutzers oder stelle ihm eine alternative Anmeldemethode zur Verfügung.
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 Bundesland=state Vorgeschlagen: Protokoll, dass ein Testtoken empfangen wurde

Doppelte und verpasste Termine

Mit dem kontoübergreifenden Schutz werden Ereignisse versucht, die noch nicht zugestellt wurden. Daher kann es vorkommen, dass Sie dasselbe Ereignis mehrmals erhalten. Wenn dies wiederholte Aktionen verursachen kann, die Ihre Nutzer stören, sollten Sie die jti-Anforderung (eine eindeutige Kennung für ein Ereignis) verwenden, um die Ereignisse zu deduplizieren. Es gibt externe Tools wie Google Cloud Dataflow, mit denen Sie den De-Dup-Datenfluss ausführen können.

Ereignisse werden mit eingeschränkten Wiederholungen gesendet. Wenn der Empfänger also über einen längeren Zeitraum inaktiv ist, können einige Ereignisse dauerhaft verpasst werden.

Empfänger registrieren

Registrieren Sie den Empfängerendpunkt mithilfe der RISC API, um Sicherheitsereignisse zu empfangen. Aufrufe an die RISC API müssen mit einem Autorisierungstoken versehen werden.

Sie erhalten nur für die Nutzer Ihrer Anwendung Sicherheitsereignisse. Daher muss in Ihrem GCP-Projekt ein OAuth-Zustimmungsbildschirm konfiguriert sein, um die folgenden Schritte ausführen zu können.

1. Autorisierungstoken generieren

Generieren Sie ein JWT mit den folgenden Anforderungen, 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. Diesen finden Sie 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')

Mit diesem Autorisierungstoken können RISC API-Aufrufe eine Stunde lang ausgeführt werden. Generieren Sie nach Ablauf des Tokens ein neues, um weiterhin RISC API-Aufrufe ausführen zu können.

2. RISC-Streamkonfigurations-API aufrufen

Da Sie jetzt ein Autorisierungstoken haben, können Sie mit der RISC API den Sicherheitsereignisstream Ihres Projekts konfigurieren, einschließlich der Registrierung des Empfängerendpunkts.

Sende dazu eine HTTPS-POST-Anfrage an https://risc.googleapis.com/v1beta/stream:update und gib den Empfängerendpunkt und die Arten von Sicherheitsereignissen an, für die du dich interessierst:

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 HTTP 200 zurückgibt, wurde der Ereignisstream erfolgreich konfiguriert und der Empfängerendpunkt sollte Sicherheitsereignistokens erhalten. Im nächsten Abschnitt wird beschrieben, wie Sie Ihre Streamkonfiguration und Ihren Endpunkt testen können, um zu prüfen, ob alles richtig funktioniert.

Aktuelle Streamkonfiguration abrufen und aktualisieren

Wenn Sie in Zukunft Ihre Streamkonfiguration ä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 an https://risc.googleapis.com/v1beta/stream:update zu senden.

Ereignisstream beenden und fortsetzen

Wenn du den Veranstaltungsstream von Google beenden musst, stelle eine autorisierte POST-Anfrage an https://risc.googleapis.com/v1beta/stream/status:update mit { "status": "disabled" } im Anfragetext. Wenn der Stream deaktiviert ist, sendet Google keine Ereignisse an Ihren Endpunkt und puffert Sicherheitsereignisse nicht, wenn sie auftreten. Senden Sie { "status": "enabled" } an denselben Endpunkt, um den Ereignisstream wieder zu aktivieren.

3. Optional: Streamkonfiguration testen

Sie können prüfen, ob die Streamkonfiguration und der Empfängerendpunkt ordnungsgemäß funktionieren, indem Sie über Ihren Ereignisstream ein Bestätigungstoken senden. Dieses Token kann einen eindeutigen String enthalten, mit dem Sie überprüfen können, ob das Token an Ihrem Endpunkt empfangen wurde.

Stellen Sie eine autorisierte HTTPS-POST-Anfrage an https://risc.googleapis.com/v1beta/stream:verify, um ein Bestätigungstoken anzufordern. Geben Sie im Hauptteil der Anfrage einen identifizierenden String 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 dann beispielsweise Bestätigungstokens verarbeitet, indem Sie sie einfach protokollieren, können Sie in Ihren Logs prüfen, ob das Token empfangen wurde.

Fehlercode-Referenz

Die RISC API kann folgende Fehler zurückgeben:

Fehlercode Fehlermeldung Empfohlene Maßnahmen
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 $fieldname in Ihrer Anfrage an.
401 Nicht autorisiert. Die Autorisierung ist fehlgeschlagen. Achten Sie darauf, dass Sie der Anfrage ein Autorisierungstoken angehängt haben und dass dieses gültig und nicht abgelaufen ist.
403 Der Bereitstellungsendpunkt muss eine HTTPS-URL sein. Ihr Bereitstellungsendpunkt (d.h. der Endpunkt, an den RISC-Ereignisse gesendet werden sollen) muss HTTPS sein. RISC-Ereignisse werden nicht an HTTP-URLs gesendet.
403 Die vorhandene Streamkonfiguration 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 es dann nach einer Stunde noch einmal.
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. Hier erfahren Sie, wie Sie alle mit einem Projekt verknüpften Dienstkonten aufrufen können.
403 Das Dienstkonto muss in Ihrem Projekt Bearbeitungsberechtigungen haben. Rufen Sie die Google Cloud Platform Console Ihres Projekts auf und gewähren Sie dem Dienstkonto, mit dem die Berechtigung zum Bearbeiten/Inhaber für Aufrufe für Ihr Projekt erteilt wird, diese Anleitung.
403 Streamverwaltungs-APIs sollten nur von einem Dienstkonto aufgerufen werden. Weitere Informationen zum Aufrufen von Google APIs mit einem Dienstkonto
403 Der Bereitstellungsendpunkt gehört zu keiner Ihrer Projektdomains. Jedes Projekt hat eine Reihe von autorisierten Domains. Wenn dein Bereitstellungsendpunkt (d.h. der Endpunkt, an den deine RISC-Ereignisse gesendet werden sollen) nicht auf einem davon gehostet wird, musst du diesem Satz die Domain des Endpunkts hinzufügen.
403 Damit Sie diese API verwenden können, muss in Ihrem Projekt mindestens ein OAuth-Client konfiguriert sein. RISC funktioniert nur, wenn Sie eine Anwendung erstellen, 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 durch Google für unsere APIs
403

Nicht unterstützter Status.

Ungültiger Status

Derzeit werden nur die Streamstatus „enabled“ und „disabled“ unterstützt.
404

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 Streamkonfiguration zu erstellen.
4XX/5XX Der Status kann nicht aktualisiert werden. Weitere Informationen finden Sie in der Fehlermeldung.

Zugriffstokenbereiche

Wenn Sie sich für die Authentifizierung bei der RISC API entscheiden, sollten Sie die folgenden 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

Benötigen Sie Hilfe?

Sehen Sie sich zuerst den Abschnitt zu Fehlercode-Referenzen an. Falls Sie weitere Fragen haben, posten Sie sie auf Stack Overflow mit dem Tag #SecEvents.