Schützen Sie Benutzerkonten mit Cross-Account Protection

Wenn Ihre App es Benutzern ermöglicht, sich über Google bei ihren Konten anzumelden, können Sie die Sicherheit der Konten dieser gemeinsam genutzten Benutzer verbessern, indem Sie die Benachrichtigungen zu Sicherheitsereignissen abhören und darauf reagieren, die vom Dienst für den kontoübergreifenden Schutz bereitgestellt werden.

Diese Benachrichtigungen machen Sie auf größere Änderungen an den Google-Konten Ihrer Nutzer aufmerksam, die häufig auch Auswirkungen auf die Sicherheit ihrer Konten bei Ihrer App haben können. Wenn beispielsweise das Google-Konto eines Nutzers gehackt wird, kann dies möglicherweise dazu führen, dass das Konto des Nutzers bei Ihrer App durch die Wiederherstellung des E-Mail-Kontos oder die Verwendung von Single Sign-On kompromittiert wird.

Um Ihnen dabei zu helfen, das Risikopotenzial solcher Ereignisse zu mindern, sendet Google Ihre Dienstobjekte, sogenannte Sicherheitsereignis-Tokens. Diese Token geben nur sehr wenige Informationen preis – nur die Art des Sicherheitsereignisses und den Zeitpunkt, zu dem es aufgetreten ist, sowie die Kennung des betroffenen Benutzers –, aber Sie können sie verwenden, um entsprechende Maßnahmen zu ergreifen. Wenn beispielsweise das Google-Konto eines Nutzers kompromittiert wurde, können Sie die Anmeldung mit Google für diesen Nutzer vorübergehend deaktivieren und verhindern, dass E-Mails zur Kontowiederherstellung an die Gmail-Adresse des Nutzers gesendet werden.

Der Cross-Account-Schutz basiert auf dem RISC-Standard , der von der OpenID Foundation entwickelt wurde.

Überblick

Um den kontoü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 Consoleein.

  2. Erstellen Sie einen Ereignisempfänger-Endpunkt, an den Google Sicherheitsereignis-Tokens 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 Sicherheitsereignis-Token zu erhalten.

Voraussetzung

Sie erhalten Sicherheitsereignis-Token nur für Google-Nutzer, die Ihrem Dienst die Erlaubnis erteilt haben, auf ihre Profilinformationen oder E-Mail-Adressen zuzugreifen. Sie erhalten diese Berechtigung, indem Sie die profile oder E- email Bereiche anfordern. Die neueren Sign In With Google- oder die älteren Google Sign-in- SDKs fordern diese Bereiche standardmäßig an, aber wenn Sie nicht die Standardeinstellungen verwenden oder direkt auf den OpenID Connect-Endpunkt von Google zugreifen, stellen Sie sicher, dass Sie mindestens einen dieser Bereiche anfordern Bereiche.

Richten Sie ein Projekt im API Consoleein

Bevor Sie Sicherheitsereignis-Token empfangen können, müssen Sie ein Dienstkonto erstellen und die RISC-API in IhremAPI Console Projekt aktivieren. Sie müssen dasselbeAPI Console Projekt verwenden, das Sie für den Zugriff auf Google-Dienste wie Google Sign-in in Ihrer App verwenden.

So erstellen Sie das Dienstkonto:

  1. Öffnen Sie den API ConsoleCredentials page . Wenn Sie dazu aufgefordert werden, wählen Sie dasAPI ConsoleProjekt aus, das Sie für den Zugriff auf Google-Dienste in Ihrer App verwenden.

  2. Klicken Sie auf Anmeldeinformationen erstellen > Dienstkonto .

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

  4. Erstellen Sie einen Schlüssel für Ihr neu erstelltes Dienstkonto. 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 Dienstkonto-Anmeldeinformationen enthält. Bewahren Sie diese Datei an einem sicheren, aber auch für Ihren Ereignisempfängerendpunkt zugänglichen Ort auf.

Notieren Sie sich auf der Seite „Anmeldedaten“ Ihres Projekts auch die Client-IDs, die Sie für „Mit Google anmelden“ oder „Google-Anmeldung (alt)“ verwenden. Normalerweise haben Sie eine Client-ID für jede Plattform, die Sie unterstützen. 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 imAPI Console. Stellen Sie sicher, dass das Projekt, das Sie für den Zugriff auf Google-Dienste verwenden, noch ausgewählt ist.

  2. Lesen Sie die RISC-Bedingungen und vergewissern Sie sich, 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 Ereignisempfänger-Endpunkt

Um Benachrichtigungen zu Sicherheitsereignissen von Google zu erhalten, erstellen Sie einen HTTPS-Endpunkt, der HTTPS-POST-Anforderungen verarbeitet. Nachdem Sie diesen Endpunkt registriert haben (siehe unten), beginnt Google damit, kryptografisch signierte Zeichenfolgen, sogenannte Sicherheitsereignis-Token, an den Endpunkt zu senden. Sicherheitsereignis-Token sind signierte JWTs, die Informationen zu einem einzelnen sicherheitsbezogenen Ereignis enthalten.

Für jedes Sicherheitsereignis-Token, das Sie an Ihrem Endpunkt erhalten, validieren und decodieren Sie zuerst das Token und behandeln Sie dann das Sicherheitsereignis entsprechend Ihrem Dienst. Es ist wichtig , das Ereignistoken vor der Dekodierung zu validieren, um böswillige Angriffe von böswilligen Akteuren zu verhindern. In den folgenden Abschnitten werden diese Aufgaben beschrieben:

1. Decodieren und validieren Sie das Sicherheitsereignis-Token

Da Sicherheitsereignistoken eine bestimmte Art von JWT sind, können Sie jede JWT-Bibliothek verwenden, z. B. eine auf jwt.io aufgelistete, um sie zu decodieren und zu validieren. Unabhängig davon, welche Bibliothek Sie verwenden, muss Ihr Token-Validierungscode Folgendes tun:

  1. Rufen Sie die Aussteller-ID des kontoübergreifenden Schutzes ( issuer ) und den URI des Signaturschlüsselzertifikats ( jwks_uri ) aus dem RISC-Konfigurationsdokument von Google ab, das Sie unter https://accounts.google.com/.well-known/risc-configuration finden.
  2. Rufen Sie mit der JWT-Bibliothek Ihrer Wahl die Signaturschlüssel-ID aus dem Header des Sicherheitsereignistokens ab.
  3. Rufen Sie den öffentlichen Schlüssel mit der Schlüssel-ID, die Sie im vorherigen Schritt erhalten haben, aus dem Signaturschlüsselzertifikatsdokument von Google ab. 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. Überprü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.
    • Der aud -Anspruch des Tokens ist eine der Client-IDs Ihrer Apps.
    • Der iss Claim 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 Sicherheitsereignis-Token historische Ereignisse darstellen und als solche nicht ablaufen.

Zum Beispiel:

Java

Verwendung 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

Nach der Dekodierung sieht ein Sicherheitsereignis-Token wie im folgenden Beispiel 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 (Ihr Dienst) an. Sie haben diese Behauptungen im vorherigen Schritt bestätigt.

Der jti Claim ist eine Zeichenfolge, die ein einzelnes Sicherheitsereignis identifiziert und für den Stream eindeutig ist. Sie können diese Kennung verwenden, um nachzuverfolgen, welche Sicherheitsereignisse Sie erhalten haben.

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

Der subject identifiziert einen bestimmten Nutzer mit der eindeutigen Google-Konto-ID des Nutzers ( sub ). Diese Google-Konto-ID ist dieselbe Kennung ( sub ), die in den JWT-ID-Tokens enthalten ist, die von der neueren Sign In With Google ( Javascript , HTML )-Bibliothek, der alten Google-Anmeldebibliothek oder OpenID Connect ausgegeben werden. Wenn der subject_type des Anspruchs id_token_claims ist, kann er auch ein E- email -Feld mit der E-Mail-Adresse des Benutzers enthalten.

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

Unterstützte Ereignistypen

Der kontoü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 Konto des Benutzers erneut, indem Sie seine derzeit 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.

Empfohlen : Wenn das Token für den Zugriff auf andere Google-APIs bestimmt 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 hijacking war , sichern Sie das Konto des Benutzers erneut, indem Sie seine derzeit geöffneten Sitzungen beenden.

Empfohlen : Wenn der Grund für die Deaktivierung des Kontos bulk-account war, analysieren Sie die Aktivität des Benutzers in Ihrem Dienst und legen Sie geeignete Folgemaßnahmen fest.

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

https://schemas.openid.net/secevent/risc/event-type/account-enabled Empfohlen : Aktivieren Sie die Google-Anmeldung für den Nutzer erneut und aktivieren Sie die Kontowiederherstellung mit der E-Mail-Adresse des Google-Kontos des Nutzers erneut.
https://schemas.openid.net/secevent/risc/event-type/account-purged Empfohlen : Löschen Sie das Konto des Benutzers oder stellen Sie 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 Staat = state Empfohlen : Protokollieren, dass ein Testtoken empfangen wurde.

Doppelte und verpasste Ereignisse

Der kontoübergreifende Schutz wird versuchen, 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 könnte, die Ihren Benutzern Unannehmlichkeiten bereiten, ziehen Sie die Verwendung des jti Claims (eine eindeutige Kennung für ein Ereignis) in Betracht, um die Ereignisse zu deduplizieren. Es gibt externe Tools wie Google Cloud Dataflow , die Ihnen bei der Ausführung des Deduplizierungsdatenflusses helfen können.

Beachten Sie, dass Ereignisse mit begrenzten Wiederholungsversuchen übermittelt werden. Wenn Ihr Receiver also für einen längeren Zeitraum ausgefallen ist, können Sie einige Ereignisse dauerhaft verpassen.

Registrieren Sie Ihren Empfänger

Um mit dem Empfang von Sicherheitsereignissen zu beginnen, registrieren Sie Ihren Empfängerendpunkt mithilfe der RISC-API. Aufrufe an die RISC-API müssen von einem Autorisierungstoken begleitet werden.

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

1. Generieren Sie ein Autorisierungstoken

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

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

Zum Beispiel:

Java

Verwenden von 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 verwendet werden, um eine Stunde lang RISC-API-Aufrufe durchzuführen. 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 nun über ein Autorisierungstoken verfügen, können Sie die RISC-API verwenden, um den Sicherheitsereignisstrom Ihres Projekts zu konfigurieren, einschließlich der Registrierung Ihres Empfängerendpunkts.

Stellen Sie dazu eine HTTPS-POST-Anforderung 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
  ]
}

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

Holen und aktualisieren Sie Ihre aktuelle Stream-Konfiguration

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

Beenden Sie den Ereignisstream und setzen Sie ihn fort

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

3. Optional: Testen Sie Ihre Stream-Konfiguration

Sie können überprüfen, ob Ihre Streamkonfiguration und Ihr Empfängerendpunkt ordnungsgemäß zusammenarbeiten, indem Sie ein Überprüfungstoken über Ihren Ereignisstream 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 Verifizierungstoken anzufordern, senden Sie eine autorisierte HTTPS-POST-Anforderung an https://risc.googleapis.com/v1beta/stream:verify . Geben Sie im Text der Anfrage eine identifizierende Zeichenfolge an:

{
  "state": "ANYTHING"
}

Zum 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 Verifizierungstoken an den von Ihnen registrierten Endpunkt gesendet. Wenn Ihr Endpunkt beispielsweise Verifizierungstoken verarbeitet, indem er sie einfach protokolliert, 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 geparst werden. Bitte geben Sie $fieldname in Ihre Anfrage ein.
401 Unbefugt. Autorisation fehlgeschlagen. Stellen Sie sicher, dass Sie der Anfrage ein Autorisierungstoken angehängt haben und dass das Token gültig und nicht abgelaufen ist.
403 Der Übermittlungsendpunkt muss eine HTTPS-URL sein. Ihr Übermittlungsendpunkt (dh der Endpunkt, an den RISC-Ereignisse übermittelt werden sollen) muss HTTPS sein. Wir senden keine RISC-Ereignisse an HTTP-URLs.
403 Die vorhandene Stream-Konfiguration verfügt nicht über eine spezifikationskonforme Bereitstellungsmethode für RISC. Ihr Google Cloud-Projekt muss bereits über eine RISC-Konfiguration verfügen. Wenn Sie Firebase verwenden und die Google-Anmeldung aktiviert ist, verwaltet Firebase RISC für Ihr Projekt. Sie können keine benutzerdefinierte Konfiguration erstellen. Wenn Sie die Google-Anmeldung nicht für Ihr Firebase-Projekt verwenden, deaktivieren Sie sie bitte und versuchen Sie nach einer Stunde erneut, sie zu aktualisieren.
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 mit einem gelöschten Projekt verknüpft ist. Erfahren Sie , wie Sie alle einem Projekt zugeordneten Dienstkonten anzeigen .
403 Das Dienstkonto muss in Ihrem Projekt über Editorberechtigungen verfügen. Gehen Sie zur Google Cloud Platform-Konsole Ihres Projekts und erteilen Sie dem Dienstkonto, das den Aufruf-Bearbeiter/Eigentümer durchführt, die Berechtigung für Ihr Projekt, indem Sie diese Anleitung befolgen .
403 Streamverwaltungs-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 hat eine Reihe von autorisierten Domänen. Wenn Ihr Zustellungsendpunkt (dh der Endpunkt, an den Sie RISC-Ereignisse liefern sollen) nicht auf einem davon gehostet wird, müssen Sie die Domäne des Endpunkts zu diesem Satz hinzufügen.
403 Um diese API verwenden zu können, muss für Ihr Projekt mindestens ein OAuth-Client konfiguriert sein. RISC funktioniert nur, wenn Sie eine App erstellen, die die Google-Anmeldung unterstützt. Diese Verbindung erfordert einen OAuth-Client. Wenn Ihr Projekt keine OAuth-Clients hat, ist RISC wahrscheinlich nicht hilfreich für Sie. Erfahren Sie mehr über die Verwendung von OAuth durch Google für unsere APIs .
403

Nicht unterstützter Status.

Ungültiger Status.

Wir unterstützen derzeit nur die Stream-Status „ enabled “ und „ disabled “.
404

Das Projekt hat keine RISC-Konfiguration.

Projekt hat keine vorhandene RISC-Konfiguration, Status kann nicht aktualisiert werden.

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. Weitere Informationen finden Sie in der detaillierten Fehlermeldung.

Zugriffstokenbereiche

Sollten Sie sich entscheiden, Zugriffstoken für die Authentifizierung bei der RISC-API zu verwenden, sind dies die Bereiche, die Ihre Anwendung anfordern muss:

Endpunkt Zielfernrohr
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?

Sehen Sie sich zuerst unseren Abschnitt mit Referenzen zu Fehlercodes an. Wenn Sie noch Fragen haben, posten Sie sie auf Stack Overflow mit dem Tag #SecEvents .