Wenn Nutzer sich in Ihrer App mit Google in ihren Konten anmelden können, können Sie die Sicherheit der Konten dieser gemeinsamen Nutzer verbessern, indem Sie auf die Sicherheitsereignisbenachrichtigungen des produktübergreifenden Kontoschutzes reagieren.
Diese Benachrichtigungen informieren Sie über wichtige Änderungen an den Google-Konten Ihrer Nutzer, die oft auch Sicherheitsrisiken für ihre Konten in Ihrer App mit sich bringen. Wenn beispielsweise das Google-Konto eines Nutzers gehackt wird, kann dies möglicherweise dazu führen, dass das Konto des Nutzers in Ihrer App durch die Wiederherstellung des E-Mail-Kontos oder die Verwendung von Single Sign-On manipuliert wird.
Damit Sie das Risikopotenzial solcher Ereignisse minimieren können, sendet Google Ihrem Dienst Objekte, die als Sicherheitsereignistokens bezeichnet werden. Diese Tokens enthalten nur sehr wenige Informationen, nämlich den Typ des Sicherheitsereignisses, den Zeitpunkt des Ereignisses und die ID des betroffenen Nutzers. Sie können sie jedoch verwenden, um angemessene Maßnahmen zu ergreifen. Wenn das Google-Konto eines Nutzers beispielsweise gehackt 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 produktübergreifende Kontoschutz basiert auf dem RISC-Standard, der von der OpenID Foundation entwickelt wurde.
Übersicht
Wenn Sie den produktübergreifenden Kontoschutz mit Ihrer App oder Ihrem Dienst verwenden möchten, müssen Sie die folgenden Aufgaben ausführen:
Richten Sie Ihr Projekt in der API Consoleein.
Erstellen Sie einen Ereignisempfänger-Endpunkt, an den Google Sicherheitstoken für Ereignisse sendet. Dieser Endpunkt ist dafür verantwortlich, die empfangenen Tokens zu validieren und dann auf Sicherheitsereignisse zu reagieren.
Registrieren Sie Ihren Endpunkt bei Google, um Sicherheitshinweis-Tokens zu erhalten.
Voraussetzungen
Sie erhalten nur Sicherheitstokens 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 Bereiche profile oder email anfordern. Die neueren SDKs für Mit Google anmelden oder die älteren SDKs für Google-Anmeldung fordern diese Bereiche standardmäßig an. Wenn Sie jedoch nicht die Standardeinstellungen verwenden oder direkt auf den OpenID Connect-Endpunkt von Google zugreifen, müssen Sie mindestens einen dieser Bereiche anfordern.
Richten Sie ein Projekt in der API Consoleein.
Bevor Sie Sicherheitstoken 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, mit dem Sie in Ihrer App auf Google-Dienste wie Google Log-in zugreifen.
So erstellen Sie das Dienstkonto:
Öffnen Sie API Console Credentials page. Wählen Sie bei Aufforderung dasAPI Console-Projekt aus, mit dem Sie in Ihrer App auf Google-Dienste zugreifen.
Klicken Sie auf Anmeldedaten erstellen > Dienstkonto.
Erstellen Sie ein neues Dienstkonto mit der Rolle „Administrator von RISC-Konfigurationen“ (
roles/riscconfigs.admin) gemäß dieser Anleitung.Erstellen Sie einen Schlüssel für das neu erstellte Dienstkonto. Wählen Sie den JSON-Schlüsseltyp aus und klicken Sie dann auf Erstellen. Wenn der Schlüssel erstellt wird, laden Sie eine JSON-Datei herunter, die die Anmeldedaten Ihres Dienstkontos enthält. Bewahren Sie diese Datei an einem sicheren Ort auf, auf den Ihr Event-Empfängerendpunkt zugreifen kann.
Notieren Sie sich auf der Seite „Anmeldedaten“ Ihres Projekts auch die Client-IDs, die Sie für „Über Google anmelden“ oder „Google-Anmeldung“ (Legacy) verwenden. Normalerweise haben Sie für jede unterstützte Plattform eine Client-ID. Sie benötigen diese Client-IDs, um Sicherheitsereignistokens zu validieren, wie im nächsten Abschnitt beschrieben.
So aktivieren Sie die RISC API:
Öffnen Sie die RISC API-Seite in derAPI Console. Achten Sie darauf, dass das Projekt, mit dem Sie auf Google-Dienste zugreifen, weiterhin ausgewählt ist.
Lesen Sie die RISC-Nutzungsbedingungen und vergewissern Sie sich, dass Sie die Anforderungen verstehen.
Wenn Sie die API für ein Projekt aktivieren, das einer Organisation gehört, müssen Sie berechtigt sein, Ihre Organisation an die RISC-Nutzungsbedingungen zu binden.
Klicken Sie nur dann auf Aktivieren, wenn Sie den RISC-Nutzungsbedingungen zustimmen.
Ereignisempfänger-Endpunkt erstellen
Wenn Sie Sicherheitsereignisbenachrichtigungen 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 namens Sicherheitsereignis-Tokens an den Endpunkt zu senden. Sicherheitsereignis-Tokens sind signierte JWTs, die Informationen zu einem einzelnen sicherheitsrelevanten Ereignis enthalten.
Für jedes Sicherheitstoken, das Sie an Ihrem Endpunkt empfangen, müssen Sie es zuerst validieren und decodieren. Anschließend müssen Sie das Sicherheitsereignis entsprechend Ihrem Dienst verarbeiten. Es ist unbedingt erforderlich, das Ereignistoken vor dem Decodieren zu validieren, um böswillige Angriffe von böswilligen Akteuren zu verhindern. In den folgenden Abschnitten werden diese Aufgaben beschrieben:
1. Sicherheitsereignistoken decodieren und validieren
Da Sicherheitsereignistokens eine spezielle Art von JWT sind, können Sie jede JWT-Bibliothek, z. B. eine, die auf jwt.io aufgeführt ist, verwenden, um sie zu decodieren und zu validieren. Unabhängig davon, welche Bibliothek Sie verwenden, muss Ihr Code zur Tokenvalidierung Folgendes tun:
- Rufen Sie die Aussteller-ID für den kontenübergreifenden Schutz (
issuer) und den URI des Zertifikats für den Signaturschlüssel (jwks_uri) aus dem RISC-Konfigurationsdokument von Google unterhttps://accounts.google.com/.well-known/risc-configurationab. - Rufen Sie mit der JWT-Bibliothek Ihrer Wahl die Signaturschlüssel-ID aus dem Header des Sicherheitsereignistokens ab.
- Rufen Sie aus dem Dokument mit dem Zertifikat für den 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.
- Prüfen Sie mit der JWT-Bibliothek Ihrer Wahl Folgendes:
- Das Sicherheitstoken wird mit dem öffentlichen Schlüssel signiert, den Sie im vorherigen Schritt erhalten haben.
- Die Anforderung
auddes Tokens ist eine der Client-IDs Ihrer Apps. - Die
iss-Anforderung des Tokens stimmt mit der Aussteller-ID überein, die Sie aus dem RISC-Discovery-Dokument erhalten haben. Sie müssen das Ablaufdatum des Tokens (exp) nicht prüfen, da Sicherheitsereignis-Tokens historische Ereignisse darstellen und daher nicht ablaufen.
Beispiel:
Java
java-jwt und jwks-rsa-java verwenden:
public DecodedJWT validateSecurityEventToken(String token) {
DecodedJWT jwt = null;
try {
// In a real implementation, get these values from
// https://accounts.google.com/.well-known/risc-configuration
String issuer = "accounts.google.com";
String jwksUri = "https://www.googleapis.com/oauth2/v3/certs";
// Get the ID of the key used to sign the token.
DecodedJWT unverifiedJwt = JWT.decode(token);
String keyId = unverifiedJwt.getKeyId();
// Get the public key from Google.
JwkProvider googleCerts = new UrlJwkProvider(new URL(jwksUri), null, null);
PublicKey publicKey = googleCerts.get(keyId).getPublicKey();
// Verify and decode the token.
Algorithm rsa = Algorithm.RSA256((RSAPublicKey) publicKey, null);
JWTVerifier verifier = JWT.require(rsa)
.withIssuer(issuer)
// Get your apps' client IDs from the API console:
// https://console.developers.google.com/apis/credentials?project=_
.withAudience("123456789-abcedfgh.apps.googleusercontent.com",
"123456789-ijklmnop.apps.googleusercontent.com",
"123456789-qrstuvwx.apps.googleusercontent.com")
.acceptLeeway(Long.MAX_VALUE) // Don't check for expiration.
.build();
jwt = verifier.verify(token);
} catch (JwkException e) {
// Key not found. Return HTTP 400.
} catch (InvalidClaimException e) {
} catch (JWTDecodeException exception) {
// Malformed token. Return HTTP 400.
} catch (MalformedURLException e) {
// Invalid JWKS URI.
}
return jwt;
}
Python
import json
import jwt # pip install pyjwt
import requests # pip install requests
def validate_security_token(token, client_ids):
# Get Google's RISC configuration.
risc_config_uri = 'https://accounts.google.com/.well-known/risc-configuration'
risc_config = requests.get(risc_config_uri).json()
# Get the public key used to sign the token.
google_certs = requests.get(risc_config['jwks_uri']).json()
jwt_header = jwt.get_unverified_header(token)
key_id = jwt_header['kid']
public_key = None
for key in google_certs['keys']:
if key['kid'] == key_id:
public_key = jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps(key))
if not public_key:
raise Exception('Public key certificate not found.')
# In this situation, return HTTP 400
# Decode the token, validating its signature, audience, and issuer.
try:
token_data = jwt.decode(token, public_key, algorithms='RS256',
options={'verify_exp': False},
audience=client_ids, issuer=risc_config['issuer'])
except:
raise
# Validation failed. Return HTTP 400.
return token_data
# Get your apps' client IDs from the API console:
# https://console.developers.google.com/apis/credentials?project=_
client_ids = ['123456789-abcedfgh.apps.googleusercontent.com',
'123456789-ijklmnop.apps.googleusercontent.com',
'123456789-qrstuvwx.apps.googleusercontent.com']
token_data = validate_security_token(token, client_ids)
Wenn das Token gültig ist und erfolgreich decodiert wurde, geben Sie den HTTP-Statuscode 202 zurück. Reagieren Sie dann auf das durch das Token angegebene Sicherheitsereignis.
2. Sicherheitsereignisse verarbeiten
Ein decodiertes Sicherheitsereignistoken sieht in etwa so aus:
{
"iss": "https://accounts.google.com/",
"aud": "123456789-abcedfgh.apps.googleusercontent.com",
"iat": 1508184845,
"jti": "756E69717565206964656E746966696572",
"events": {
"https://schemas.openid.net/secevent/risc/event-type/account-disabled": {
"subject": {
"subject_type": "iss-sub",
"iss": "https://accounts.google.com/",
"sub": "7375626A656374"
},
"reason": "hijacking"
}
}
}
Die Ansprüche iss und aud geben den Aussteller des Tokens (Google) und den beabsichtigten Empfänger des Tokens (Ihr Dienst) an. Sie haben diese Ansprüche im vorherigen Schritt bestätigt.
Der jti-Anspruch ist ein String, der ein einzelnes Sicherheitsereignis identifiziert und für den Stream eindeutig ist. Mit dieser Kennung können Sie nachvollziehen, welche Sicherheitsereignisse Sie erhalten haben.
Der events-Anspruch enthält Informationen zum Sicherheitsereignis, das das Token repräsentiert. Dieser Anspruch ist eine Zuordnung von einer Ereignistyp-ID zu einem subject-Anspruch, der den Nutzer angibt, auf den sich dieses Ereignis bezieht, und zu allen zusätzlichen Details zum Ereignis, die möglicherweise verfügbar sind.
Mit der subject-Anforderung wird ein bestimmter Nutzer mit der eindeutigen Google-Konto-ID des Nutzers (sub) identifiziert. Diese Google-Konto-ID ist dieselbe Kennung (sub), die in den JWT-ID-Tokens enthalten ist, die von der neueren Bibliothek „Mit Google anmelden“ (Javascript, HTML), der alten Google-Anmeldebibliothek oder OpenID Connect ausgegeben werden. Wenn die subject_type des Anspruchs id_token_claims ist, kann sie auch ein email-Feld mit der E-Mail-Adresse des Nutzers enthalten.
Anhand der Informationen im events-Anspruch können Sie geeignete Maßnahmen für den Ereignistyp im Konto des angegebenen Nutzers ergreifen.
OAuth-Token-Kennungen
Für OAuth-Ereignisse zu einzelnen Tokens enthält der Kennungstyp token subject die folgenden Felder:
token_type: Nurrefresh_tokenwird unterstützt.token_identifier_alg: Mögliche Werte finden Sie in der Tabelle unten.token: Siehe Tabelle unten.
| token_identifier_alg | token |
|---|---|
prefix |
Die ersten 16 Zeichen des Tokens. |
hash_base64_sha512_sha512 |
Der doppelte Hash des Tokens mit SHA-512. |
Wenn Sie diese Ereignisse einbinden, sollten Sie Ihre Tokens anhand dieser möglichen Werte indexieren, um einen schnellen Abgleich zu ermöglichen, wenn das Ereignis empfangen wird.
Unterstützte Ereignistypen
Der produktübergreifende Kontoschutz unterstützt die folgenden Arten von Sicherheitsereignissen:
| Ereignistyp | Attribute | So reagieren Sie |
|---|---|---|
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked |
Erforderlich: Sichern Sie das Konto des Nutzers neu, indem Sie die aktuell geöffneten Sitzungen beenden. | |
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked |
Erforderlich: Wenn das Token für Google-Anmeldung verwendet wird, beenden Sie die aktuell geöffneten Sitzungen des Nutzers. Außerdem können Sie dem Nutzer vorschlagen, eine alternative Anmeldemethode einzurichten. Empfohlen: Wenn das Token für den Zugriff auf andere Google-APIs bestimmt ist, löschen Sie alle OAuth-Tokens des Nutzers, die Sie gespeichert haben. |
|
https://schemas.openid.net/secevent/oauth/event-type/token-revoked |
Informationen zu Token-Kennungen finden Sie im Abschnitt OAuth-Token-Kennungen. |
Erforderlich: Wenn Sie das entsprechende Aktualisierungstoken speichern, löschen Sie es und fordern Sie den Nutzer auf, beim nächsten Mal, wenn ein Zugriffstoken benötigt wird, noch einmal die Einwilligung zu erteilen. |
https://schemas.openid.net/secevent/risc/event-type/account-disabled |
reason=hijacking,reason=bulk-account |
Erforderlich: Wenn das Konto aufgrund von Empfohlen: Wenn das Konto aufgrund von Empfohlen: Wenn kein Grund angegeben wurde, deaktivieren Sie die Google-Anmeldung für den Nutzer und die Kontowiederherstellung über die mit dem Google-Konto des Nutzers verknüpften E-Mail-Adresse (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 |
Vorschlag: Aktivieren Sie die Google-Anmeldung für den Nutzer und die Kontowiederherstellung mit der E-Mail-Adresse des Google-Kontos des Nutzers wieder. | |
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required |
Empfohlen: Achten Sie auf verdächtige Aktivitäten in Ihrem Dienst und ergreifen Sie entsprechende Maßnahmen. | |
https://schemas.openid.net/secevent/risc/event-type/verification |
state=state | Vorgeschlagen: Protokollieren Sie, dass ein Test-Token empfangen wurde. |
Duplizierte und verpasste Termine
Der produktübergreifende Kontoschutz versucht, Ereignisse noch einmal zu senden, die seiner Meinung nach nicht zugestellt wurden. Daher kann es vorkommen, dass Sie dasselbe Ereignis mehrmals erhalten. Wenn dies zu wiederholten Aktionen führen könnte, die Ihre Nutzer stören, sollten Sie das jti-Claim (eine eindeutige Kennung für ein Ereignis) verwenden, um die Ereignisse zu deduplizieren. Es gibt externe Tools wie Google Cloud Dataflow, die Ihnen bei der Ausführung des Deduplizierungs-Dataflows helfen können.
Ereignisse werden nur begrenzt oft noch einmal gesendet. Wenn Ihr Empfänger also über einen längeren Zeitraum nicht verfügbar ist, verpassen Sie möglicherweise einige Ereignisse dauerhaft.
Receiver registrieren
Damit Sie Sicherheitsereignisse empfangen können, müssen Sie Ihren Empfängerendpunkt mit der RISC API registrieren. Aufrufe der RISC API müssen ein Autorisierungstoken enthalten.
Sie erhalten Sicherheitsereignisse nur für die Nutzer Ihrer App. Daher müssen Sie in Ihrem GCP-Projekt einen OAuth-Zustimmungsbildschirm konfiguriert haben, bevor Sie die unten beschriebenen Schritte ausführen können.
1. Autorisierungstoken generieren
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. Sie finden ihn in der JSON-Datei, die Sie beim Erstellen des Dienstkontoschlüssels heruntergeladen haben.
Beispiel:
Java
java-jwt und die Google-Authentifizierungsbibliothek verwenden:
public static String makeBearerToken() {
String token = null;
try {
// Get signing key and client email address.
FileInputStream is = new FileInputStream("your-service-account-credentials.json");
ServiceAccountCredentials credentials =
(ServiceAccountCredentials) GoogleCredentials.fromStream(is);
PrivateKey privateKey = credentials.getPrivateKey();
String keyId = credentials.getPrivateKeyId();
String clientEmail = credentials.getClientEmail();
// Token must expire in exactly one hour.
Date issuedAt = new Date();
Date expiresAt = new Date(issuedAt.getTime() + 3600000);
// Create signed token.
Algorithm rsaKey = Algorithm.RSA256(null, (RSAPrivateKey) privateKey);
token = JWT.create()
.withIssuer(clientEmail)
.withSubject(clientEmail)
.withAudience("https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService")
.withIssuedAt(issuedAt)
.withExpiresAt(expiresAt)
.withKeyId(keyId)
.sign(rsaKey);
} catch (ClassCastException e) {
// Credentials file doesn't contain a service account key.
} catch (IOException e) {
// Credentials file couldn't be loaded.
}
return token;
}
Python
import json
import time
import jwt # pip install pyjwt
def make_bearer_token(credentials_file):
with open(credentials_file) as service_json:
service_account = json.load(service_json)
issuer = service_account['client_email']
subject = service_account['client_email']
private_key_id = service_account['private_key_id']
private_key = service_account['private_key']
issued_at = int(time.time())
expires_at = issued_at + 3600
payload = {'iss': issuer,
'sub': subject,
'aud': 'https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService',
'iat': issued_at,
'exp': expires_at}
encoded = jwt.encode(payload, private_key, algorithm='RS256',
headers={'kid': private_key_id})
return encoded
auth_token = make_bearer_token('your-service-account-credentials.json')
Dieses Autorisierungstoken kann eine Stunde lang für RISC API-Aufrufe verwendet werden. Wenn das Token abläuft, müssen Sie ein neues generieren, um weiterhin RISC API-Aufrufe auszuführen.
2. RISC-Streamkonfigurations-API aufrufen
Mit dem Autorisierungstoken können Sie jetzt die RISC API verwenden, um den Sicherheitsereignisstream Ihres Projekts zu konfigurieren, einschließlich der Registrierung Ihres Empfängerendpunkts.
Senden Sie dazu eine HTTPS-POST-Anfrage an https://risc.googleapis.com/v1beta/stream:update und geben Sie Ihren Empfängerendpunkt und die Arten von Sicherheitsereignissen an, die Sie interessieren:
POST /v1beta/stream:update HTTP/1.1
Host: risc.googleapis.com
Authorization: Bearer AUTH_TOKEN
{
"delivery": {
"delivery_method":
"https://schemas.openid.net/secevent/risc/delivery-method/push",
"url": RECEIVER_ENDPOINT
},
"events_requested": [
SECURITY_EVENT_TYPES
]
}
Beispiel:
Java
public static void configureEventStream(final String receiverEndpoint,
final List<String> eventsRequested,
String authToken) throws IOException {
ObjectMapper jsonMapper = new ObjectMapper();
String streamConfig = jsonMapper.writeValueAsString(new Object() {
public Object delivery = new Object() {
public String delivery_method =
"https://schemas.openid.net/secevent/risc/delivery-method/push";
public String url = receiverEndpoint;
};
public List<String> events_requested = eventsRequested;
});
HttpPost updateRequest = new HttpPost("https://risc.googleapis.com/v1beta/stream:update");
updateRequest.addHeader("Content-Type", "application/json");
updateRequest.addHeader("Authorization", "Bearer " + authToken);
updateRequest.setEntity(new StringEntity(streamConfig));
HttpResponse updateResponse = new DefaultHttpClient().execute(updateRequest);
Header[] responseContentTypeHeaders = updateResponse.getHeaders("Content-Type");
StatusLine responseStatus = updateResponse.getStatusLine();
int statusCode = responseStatus.getStatusCode();
HttpEntity entity = updateResponse.getEntity();
// Now handle response
}
// ...
configureEventStream(
"https://your-service.example.com/security-event-receiver",
Arrays.asList(
"https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required",
"https://schemas.openid.net/secevent/risc/event-type/account-disabled"),
authToken);
Python
import requests
def configure_event_stream(auth_token, receiver_endpoint, events_requested):
stream_update_endpoint = 'https://risc.googleapis.com/v1beta/stream:update'
headers = {'Authorization': 'Bearer {}'.format(auth_token)}
stream_cfg = {'delivery': {'delivery_method': 'https://schemas.openid.net/secevent/risc/delivery-method/push',
'url': receiver_endpoint},
'events_requested': events_requested}
response = requests.post(stream_update_endpoint, json=stream_cfg, headers=headers)
response.raise_for_status() # Raise exception for unsuccessful requests
configure_event_stream(auth_token, 'https://your-service.example.com/security-event-receiver',
['https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required',
'https://schemas.openid.net/secevent/risc/event-type/account-disabled'])
Wenn die Anfrage HTTP 200 zurückgibt, wurde der Ereignisstream erfolgreich konfiguriert und Ihr Empfängerendpunkt sollte mit dem Empfang von Sicherheitsereignistokens beginnen. 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 die Streamkonfiguration in Zukunft ändern möchten, können Sie dies tun, indem Sie eine autorisierte GET-Anfrage an https://risc.googleapis.com/v1beta/stream senden, um die aktuelle Streamkonfiguration abzurufen, den Antworttext ändern und die geänderte Konfiguration dann wie oben beschrieben an https://risc.googleapis.com/v1beta/stream:update senden.
Eventstream anhalten und fortsetzen
Wenn Sie den Ereignisstream von Google beenden möchten, senden Sie eine autorisierte POST-Anfrage an https://risc.googleapis.com/v1beta/stream/status:update mit { "status": "disabled" } im Anfragetext. Während der Stream deaktiviert ist, sendet Google keine Ereignisse an Ihren Endpunkt und puffert keine Sicherheitsereignisse, wenn sie auftreten. Wenn Sie den Ereignisstream wieder aktivieren möchten, senden Sie { "status": "enabled" } per POST an denselben Endpunkt.
3. Optional: Streamkonfiguration testen
Sie können prüfen, ob Ihre Streamkonfiguration und Ihr Empfängerendpunkt richtig zusammenarbeiten, indem Sie ein Bestätigungstoken über Ihren Eventstream senden. Dieses Token kann einen eindeutigen String enthalten, mit dem Sie bestätigen können, dass das Token an Ihrem Endpunkt empfangen wurde. Damit Sie diesen Ablauf verwenden können, müssen Sie bei der Registrierung Ihres Empfängers den Ereignistyp „https://schemas.openid.net/secevent/risc/event-type/verification“ abonnieren.
Wenn Sie ein Bestätigungstoken anfordern möchten, stellen Sie eine autorisierte HTTPS-POST-Anfrage an https://risc.googleapis.com/v1beta/stream:verify. Geben Sie im Anfragetext 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 Bestätigungstokens beispielsweise durch einfaches Protokollieren verarbeitet, können Sie Ihre Logs prüfen, um zu bestätigen, dass das Token empfangen wurde.
Fehlercode-Referenz
Die RISC API kann die folgenden Fehler zurückgeben:
| Fehlercode | Fehlermeldung | Vorgeschlagene Aktionen |
|---|---|---|
| 400 | Die Streamkonfiguration muss das Feld $fieldname enthalten. | Ihre Anfrage an den Endpunkt https://risc.googleapis.com/v1beta/stream:update ist ungültig oder kann nicht geparst werden. Geben Sie $fieldname in Ihrer Anfrage an. |
| 401 | Nicht autorisiert. | Fehler bei der Autorisierung Achten Sie darauf, dass Sie der Anfrage ein Autorisierungstoken beigefügt haben und dass das Token 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. Wir senden keine RISC-Ereignisse an HTTP-URLs. |
| 403 | Die vorhandene Streamkonfiguration hat keine spezifikationskonforme Bereitstellungsmethode für RISC. | Ihr Google Cloud-Projekt muss bereits eine RISC-Konfiguration haben. Wenn Sie Firebase verwenden und die Google-Anmeldung aktiviert haben, verwaltet Firebase RISC für Ihr Projekt. Sie können keine benutzerdefinierte Konfiguration erstellen. Wenn Sie Google-Anmeldung nicht für Ihr Firebase-Projekt verwenden, deaktivieren Sie sie und versuchen Sie es 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. Informationen zum Ansehen aller Dienstkonten, die mit einem Projekt verknüpft sind |
| 403 | Dienstkonto benötigt Berechtigung für den Zugriff auf Ihre RISC-Konfiguration | Rufen Sie das API Console Ihres Projekts auf und weisen Sie dem Dienstkonto, das die Aufrufe an Ihr Projekt ausführt, die Rolle „RISC Configuration Admin“ (roles/riscconfigs.admin) zu. Folgen Sie dazu dieser Anleitung.
|
| 403 | Streamverwaltungs-APIs sollten nur von einem Dienstkonto aufgerufen werden. | Weitere Informationen zum Aufrufen von Google APIs mit einem Dienstkonto |
| 403 | Der Lieferendpunkt gehört zu keiner der Domains Ihres Projekts. | Jedes Projekt hat eine Reihe von autorisierten Domains. Wenn Ihr Bereitstellungsendpunkt (d.h. der Endpunkt, an den RISC-Ereignisse gesendet werden sollen) nicht auf einem dieser Server gehostet wird, müssen Sie die Domain des Endpunkts dieser Gruppe hinzufügen. |
| 403 | Damit Sie diese API verwenden können, muss für Ihr Projekt mindestens ein OAuth-Client konfiguriert sein. | RISC funktioniert nur, wenn Sie eine App entwickeln, die Google Log-in unterstützt. Für diese Verbindung ist ein OAuth-Client erforderlich. Wenn Ihr Projekt keine OAuth-Clients hat, ist RISC wahrscheinlich nicht für Sie geeignet. Weitere Informationen zur Verwendung von OAuth durch Google für unsere APIs |
| 403 |
Nicht unterstützter Status. Ungültiger Status |
Derzeit werden nur die Stream-Status „enabled“ und „disabled“ unterstützt. |
| 404 |
Für das Projekt ist keine RISC-Konfiguration vorhanden. Für das Projekt ist keine RISC-Konfiguration vorhanden. Der Status kann nicht aktualisiert werden. |
Rufen Sie den Endpunkt https://risc.googleapis.com/v1beta/stream:update auf, um eine neue Streamkonfiguration zu erstellen. |
| 4XX/5XX | Der Status kann nicht aktualisiert werden. | Weitere Informationen finden Sie in der detaillierten Fehlermeldung. |
Bereiche für Zugriffstokens
Wenn Sie Zugriffstokens für die Authentifizierung bei der RISC API verwenden möchten, muss Ihre Anwendung die folgenden Bereiche anfordern:
| Endpunkt | Ebene |
|---|---|
https://risc.googleapis.com/v1beta/stream/status |
https://www.googleapis.com/auth/risc.status.readonly
ODER https://www.googleapis.com/auth/risc.status.readwrite |
https://risc.googleapis.com/v1beta/stream/status:update |
https://www.googleapis.com/auth/risc.status.readwrite |
https://risc.googleapis.com/v1beta/stream |
https://www.googleapis.com/auth/risc.configuration.readonly
ODER https://www.googleapis.com/auth/risc.configuration.readwrite
|
https://risc.googleapis.com/v1beta/stream:update |
https://www.googleapis.com/auth/risc.configuration.readwrite |
https://risc.googleapis.com/v1beta/stream:verify |
https://www.googleapis.com/auth/risc.verify |
Benötigen Sie Hilfe?
Sehen Sie sich zuerst den Abschnitt Referenz für Fehlercodes an. Wenn Sie weitere Fragen haben, posten Sie sie auf Stack Overflow mit dem Tag #SecEvents.