Wenn sich Nutzer in Ihrer App über Google in ihren Konten anmelden können, können Sie die Sicherheit der Konten dieser geteilten Nutzer verbessern, indem Sie die Benachrichtigungen zu Sicherheitsereignissen des produktübergreifenden Kontoschutzes empfangen und darauf 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 darstellen können. Wenn beispielsweise das Google-Konto eines Nutzers gehackt wurde, kann dies über die E-Mail-Kontowiederherstellung oder die Verwendung von Single Sign-On zum Zugriff auf das Konto des Nutzers in Ihrer App führen.
Um das Risikopotenzial solcher Ereignisse zu minimieren, sendet Google Ihnen Dienstobjekte, die als Sicherheitsereignis-Tokens bezeichnet werden. Diese Tokens enthalten nur sehr wenige Informationen – nur die Art des Sicherheitsereignisses, wann es aufgetreten ist und die Kennung des betroffenen Nutzers. Sie können sie jedoch verwenden, um entsprechende Maßnahmen zu ergreifen. Wenn das Google-Konto eines Nutzers beispielsweise manipuliert wurde, können Sie die Funktion „Über Google anmelden“ für diesen Nutzer vorübergehend deaktivieren und verhindern, dass E-Mails zur Kontowiederherstellung an die Gmail-Adresse des Nutzers gesendet werden.
Der produktübergreifende Kontoschutz basiert auf dem RISC-Standard, der von der OpenID Foundation entwickelt wurde.
Übersicht
Wenn Sie den produktübergreifenden Kontoschutz für Ihre App oder Ihren Dienst verwenden möchten, müssen Sie die folgenden Aufgaben ausführen:
Richten Sie Ihr Projekt in der ein.
Erstellen Sie einen Ereignisempfängerendpunkt, an den Google Sicherheitsereignistokens sendet. Dieser Endpunkt ist für die Validierung der empfangenen Tokens und die Reaktion auf Sicherheitsereignisse verantwortlich.
Registrieren Sie Ihren Endpunkt bei Google, um Sicherheitsereignis-Tokens zu erhalten.
Voraussetzungen
Sie erhalten nur Sicherheitsereignis-Tokens 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 den Bereich profile oder email anfordern. Die neueren Sign in with Google- oder die älteren 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, müssen Sie mindestens einen dieser Bereiche anfordern.
Projekt in der einrichten
Bevor Sie Sicherheitsereignis-Tokens erhalten können, müssen Sie ein Dienstkonto erstellen und die RISC API in Ihrem -Projekt aktivieren. Sie müssen dasselbe Projekt verwenden, mit dem Sie in Ihrer App auf Google-Dienste wie Google Log-in zugreifen.
So erstellen Sie das Dienstkonto:
Öffnen Sie . Wählen Sie auf Aufforderung das-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 „RISC-Konfigurationsadministrator“ (
roles/riscconfigs.admin). Folgen Sie dazu 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. Nach der Erstellung des Schlüssels laden Sie eine JSON-Datei mit den Anmeldedaten Ihres Dienstkontos herunter. Bewahren Sie diese Datei an einem sicheren Ort auf, der aber auch für Ihren Ereignisempfänger-Endpunkt zugänglich ist.
Notieren Sie sich auf der Seite „Anmeldedaten“ Ihres Projekts auch die Kunden-IDs, die Sie für die Anmeldung über Google oder die alte Google-Anmeldung verwenden. Normalerweise haben Sie eine Client-ID für jede von Ihnen unterstützte Plattform. Sie benötigen diese Client-IDs, um Sicherheitsereignis-Tokens zu validieren, wie im nächsten Abschnitt beschrieben.
So aktivieren Sie die RISC API:
Öffne die RISC API-Seite in der. Prüfen Sie, ob das Projekt, mit dem Sie auf Google-Dienste zugreifen, noch ausgewählt ist.
Lesen Sie die RISC-Bedingungen und machen Sie sich mit den Anforderungen vertraut.
Wenn Sie die API für ein Projekt aktivieren, das einer Organisation gehört, müssen Sie berechtigt sein, Ihre Organisation an die RISC-Bedingungen zu binden.
Klicken Sie nur dann auf Aktivieren, wenn Sie den RISC-Bedingungen 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), veröffentlicht Google kryptografisch signierte Strings, sogenannte Sicherheitsereignis-Tokens, am Endpunkt. Sicherheitsereignis-Tokens sind signierte JWTs, die Informationen zu einem einzelnen sicherheitsrelevanten Ereignis enthalten.
Prüfen und decodieren Sie zuerst jedes Sicherheitsereignis-Token, das Sie an Ihrem Endpunkt erhalten, und verarbeiten Sie das Sicherheitsereignis dann entsprechend Ihrem Dienst. Es ist wichtig, das Ereignistoken vor der Dekodierung zu validieren, um böswillige Angriffe von Cyberkriminellen 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 zum Decodieren und Validieren beliebige JWT-Bibliotheken verwenden, z. B. eine auf jwt.io aufgeführte. Unabhängig von der verwendeten Bibliothek muss der Code zur Tokenbestätigung Folgendes tun:
- Rufen Sie die Aussteller-ID (
issuer) und die URI des Signaturschlüsselzertifikats (jwks_uri) aus dem RISC-Konfigurationsdokument von Google unterhttps://accounts.google.com/.well-known/risc-configurationab. - Rufe mit der JWT-Bibliothek deiner Wahl die Signaturschlüssel-ID aus dem Header des Sicherheitsereignis-Tokens ab.
- Rufen Sie aus dem Zertifikatsdokument des Signaturschlüssels 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 dein Endpunkt sollte den HTTP-Fehler 400 zurückgeben.
- 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 der Client-IDs Ihrer Apps. - Die
iss-Anforderung des Tokens stimmt mit der Aussteller-ID überein, die du aus dem RISC-Discovery-Dokument erhalten hast. Sie müssen das Ablaufdatum des Tokens (exp) nicht überprüfen, da Sicherheitsereignis-Tokens für vergangene Ereignisse stehen und daher nicht ablaufen.
Beispiel:
Java
Mit java-jwt und jwks-rsa-java:
public DecodedJWT validateSecurityEventToken(String token) {
DecodedJWT jwt = null;
try {
// In a real implementation, get these values from
// https://accounts.google.com/.well-known/risc-configuration
String issuer = "accounts.google.com";
String jwksUri = "https://www.googleapis.com/oauth2/v3/certs";
// Get the ID of the key used to sign the token.
DecodedJWT unverifiedJwt = JWT.decode(token);
String keyId = unverifiedJwt.getKeyId();
// Get the public key from Google.
JwkProvider googleCerts = new UrlJwkProvider(new URL(jwksUri), null, null);
PublicKey publicKey = googleCerts.get(keyId).getPublicKey();
// Verify and decode the token.
Algorithm rsa = Algorithm.RSA256((RSAPublicKey) publicKey, null);
JWTVerifier verifier = JWT.require(rsa)
.withIssuer(issuer)
// Get your apps' client IDs from the API console:
// ?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:
# ?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, gib den HTTP-Status 202 zurück. Behandle dann das Sicherheitsereignis, das durch das Token angegeben wird.
2. Sicherheitsereignisse verarbeiten
Nach der Dekodierung sieht ein Sicherheitsereignis-Token in etwa so aus:
{
"iss": "https://accounts.google.com/",
"aud": "123456789-abcedfgh.apps.googleusercontent.com",
"iat": 1508184845,
"jti": "756E69717565206964656E746966696572",
"events": {
"https://schemas.openid.net/secevent/risc/event-type/account-disabled": {
"subject": {
"subject_type": "iss-sub",
"iss": "https://accounts.google.com/",
"sub": "7375626A656374"
},
"reason": "hijacking"
}
}
}
Die iss- und aud-Anspruche geben den Aussteller des Tokens (Google) und den beabsichtigten Empfänger des Tokens (Ihren Dienst) an. Sie haben diese Ansprüche im vorherigen Schritt bestätigt.
Der jti-Claim ist ein String, der ein einzelnes Sicherheitsereignis identifiziert und für den Stream eindeutig ist. Anhand dieser Kennung können Sie nachverfolgen, welche Sicherheitsereignisse Sie erhalten haben.
Der events-Claim enthält Informationen zum Sicherheitsereignis, das das Token darstellt. Dieser Anspruch ist eine Zuordnung einer Ereignistyp-ID zu einem subject-Anspruch, in dem der Nutzer angegeben ist, auf den sich das Ereignis bezieht, sowie alle zusätzlichen Details zum Ereignis, die verfügbar sind.
Die subject-Anfrage identifiziert einen bestimmten Nutzer anhand seiner eindeutigen Google-Konto-ID (sub). Diese Google-Konto-ID ist mit der Kennung (sub) identisch, die in den JWT-ID-Tokens enthalten ist, die von der neueren Sign in with Google-Bibliothek (Javascript, HTML), der älteren Google Sign-in-Bibliothek oder OpenID Connect ausgestellt wurden. Wenn die subject_type des Anspruchs id_token_claims ist, kann er auch ein Feld email mit der E-Mail-Adresse des Nutzers enthalten.
Verwenden Sie die Informationen in der events-Anfrage, um im Konto des angegebenen Nutzers geeignete Maßnahmen für den Ereignistyp zu ergreifen.
OAuth-Token-IDs
Bei OAuth-Ereignissen zu einzelnen Tokens enthält der Token-Subjekt-Kennungstyp 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 eine schnelle Übereinstimmung beim Empfang des Ereignisses zu ermöglichen.
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: Schützen Sie das Konto des Nutzers wieder, 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 gilt, beenden Sie die aktuell geöffneten Sitzungen. Du kannst dem Nutzer auch vorschlagen, eine alternative Anmeldemethode einzurichten. Empfohlen: Wenn das Token für den Zugriff auf andere Google APIs verwendet wird, löschen Sie alle gespeicherten OAuth-Tokens des Nutzers. |
|
https://schemas.openid.net/secevent/oauth/event-type/token-revoked |
Informationen zu Token-IDs finden Sie im Abschnitt OAuth-Token-IDs. |
Erforderlich: Wenn Sie das entsprechende Aktualisierungstoken speichern, löschen Sie es und bitten Sie den Nutzer, bei Bedarf noch einmal seine 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 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: 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 die entsprechenden Maßnahmen. | |
https://schemas.openid.net/secevent/risc/event-type/verification |
state=state | Empfohlen: Protokollieren Sie, dass ein Testtoken empfangen wurde. |
Duplizierte und verpasste Ereignisse
Der produktübergreifende Kontoschutz versucht, Ereignisse noch einmal zu senden, die seiner Meinung nach nicht zugestellt wurden. Daher erhalten Sie das Ereignis manchmal mehrmals. Wenn dies zu wiederholten Aktionen führen könnte, die für Ihre Nutzer ein Ärgernis darstellen, können Sie den Anspruch jti (eine eindeutige Kennung für ein Ereignis) verwenden, um Duplikate zu entfernen. Es gibt externe Tools wie Google Cloud Dataflow, die Sie bei der Ausführung des Datenflusses zur Datenbereinigung unterstützen können.
Ereignisse werden mit begrenzten Wiederholungen gesendet. Wenn Ihr Empfänger also über einen längeren Zeitraum nicht verfügbar ist, gehen einige Ereignisse möglicherweise verloren.
Receiver registrieren
Wenn Sie Sicherheitsereignisse erhalten möchten, registrieren Sie Ihren Empfängerendpunkt mit der RISC API. Aufrufe der RISC API müssen ein Autorisierungstoken enthalten.
Sie erhalten nur Sicherheitsereignisse für die Nutzer Ihrer App. Daher muss in Ihrem GCP-Projekt ein OAuth-Zustimmungsbildschirm konfiguriert sein, damit Sie die unten beschriebenen Schritte ausführen können.
1. Autorisierungstoken generieren
Wenn du ein Autorisierungstoken für die RISC API generieren möchtest, erstelle 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
Mit java-jwt und der Authentifizierungsbibliothek von Google:
public static String makeBearerToken() {
String token = null;
try {
// Get signing key and client email address.
FileInputStream is = new FileInputStream("your-service-account-credentials.json");
ServiceAccountCredentials credentials =
(ServiceAccountCredentials) GoogleCredentials.fromStream(is);
PrivateKey privateKey = credentials.getPrivateKey();
String keyId = credentials.getPrivateKeyId();
String clientEmail = credentials.getClientEmail();
// Token must expire in exactly one hour.
Date issuedAt = new Date();
Date expiresAt = new Date(issuedAt.getTime() + 3600000);
// Create signed token.
Algorithm rsaKey = Algorithm.RSA256(null, (RSAPrivateKey) privateKey);
token = JWT.create()
.withIssuer(clientEmail)
.withSubject(clientEmail)
.withAudience("https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService")
.withIssuedAt(issuedAt)
.withExpiresAt(expiresAt)
.withKeyId(keyId)
.sign(rsaKey);
} catch (ClassCastException e) {
// Credentials file doesn't contain a service account key.
} catch (IOException e) {
// Credentials file couldn't be loaded.
}
return token;
}
Python
import json
import time
import jwt # pip install pyjwt
def make_bearer_token(credentials_file):
with open(credentials_file) as service_json:
service_account = json.load(service_json)
issuer = service_account['client_email']
subject = service_account['client_email']
private_key_id = service_account['private_key_id']
private_key = service_account['private_key']
issued_at = int(time.time())
expires_at = issued_at + 3600
payload = {'iss': issuer,
'sub': subject,
'aud': 'https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService',
'iat': issued_at,
'exp': expires_at}
encoded = jwt.encode(payload, private_key, algorithm='RS256',
headers={'kid': private_key_id})
return encoded
auth_token = make_bearer_token('your-service-account-credentials.json')
Dieses Autorisierungstoken kann für eine Stunde für RISC API-Aufrufe verwendet werden. Wenn das Token abläuft, generieren Sie ein neues, um weiterhin RISC API-Aufrufe ausführen zu können.
2. RISC-Streamkonfigurations-API aufrufen
Nachdem Sie ein Autorisierungstoken haben, können Sie mit der RISC API den Sicherheitsereignisstream 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 sowie die Sicherheitsereignistypen 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 jetzt Sicherheitsereignis-Tokens empfangen. Im nächsten Abschnitt wird beschrieben, wie du deine Streamkonfiguration und deinen Endpunkt testen kannst, um sicherzustellen, dass alles zusammen richtig funktioniert.
Aktuelle Streamkonfiguration abrufen und aktualisieren
Wenn du die Streamkonfiguration in Zukunft ändern möchtest, kannst du eine autorisierte GET-Anfrage an https://risc.googleapis.com/v1beta/stream senden, um die aktuelle Streamkonfiguration abzurufen. Ändere dann den Antworttext und poste die geänderte Konfiguration wie oben beschrieben per POST zurück an https://risc.googleapis.com/v1beta/stream:update.
Ereignisstream 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. Solange der Stream deaktiviert ist, sendet Google keine Ereignisse an Ihren Endpunkt und puffert keine Sicherheitsereignisse. Wenn Sie den Ereignisstream wieder aktivieren möchten, POSTEN Sie { "status": "enabled" } an denselben Endpunkt.
3. Optional: Streamkonfiguration testen
Sie können prüfen, ob Ihre Streamkonfiguration und der Empfängerendpunkt richtig zusammenarbeiten, indem Sie ein Bestätigungstoken über Ihren Ereignisstream senden. Dieses Token kann einen eindeutigen String enthalten, mit dem du prüfen kannst, ob das Token an deinem Endpunkt empfangen wurde. Wenn du diesen Ablauf verwenden möchtest, musst du den Ereignistyp https://schemas.openid.net/secevent/risc/event-type/verification abonnieren, wenn du deinen Empfänger registrierst.
Wenn Sie ein Bestätigungstoken anfordern möchten, senden Sie eine autorisierte HTTPS-POST-Anfrage an https://risc.googleapis.com/v1beta/stream:verify. Geben Sie im Anfragetext einen eindeutigen 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 dir registrierten Endpunkt gesendet. Wenn Ihr Endpunkt beispielsweise Bestätigungstokens einfach protokolliert, können Sie anhand der Protokolle prüfen, ob das Token empfangen wurde.
Fehlercode-Referenz
Die RISC API kann die folgenden Fehler zurückgeben:
| Fehlercode | Fehlermeldung | Vorgeschlagene 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 analysiert werden. Fügen Sie $fieldname in Ihre Anfrage ein. |
| 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 Übermittlungsendpunkt muss eine HTTPS-URL sein. | Der Übermittlungsendpunkt (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 Google Sign-In aktiviert haben, wird RISC für Ihr Projekt von Firebase verwaltet. 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 noch einmal, die Aktualisierung durchzuführen. |
| 403 | Das Projekt konnte nicht gefunden werden. | Achten Sie darauf, das richtige Dienstkonto für das richtige Projekt zu 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 | Das Dienstkonto benötigt die Berechtigung zum Zugriff auf Ihre RISC-Konfiguration. | Rufen Sie die Seite 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 | APIs zur Streamverwaltung sollten nur von einem Dienstkonto aufgerufen werden. | Weitere Informationen zum Aufrufen von Google APIs mit einem Dienstkonto |
| 403 | Der Übermittlungsendpunkt 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 zu diesem Set 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 App entwickeln, die Google Sign-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 Streamstatus „enabled“ und „disabled“ unterstützt. |
| 404 |
Das Projekt hat keine RISC-Konfiguration. Das Projekt hat keine RISC-Konfiguration. Der Status kann nicht aktualisiert werden. |
Rufe 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. |
Zugriffsbereiche für Zugriffstokens
Wenn Sie sich für die Verwendung von Zugriffstokens für die Authentifizierung bei der RISC API entscheiden, müssen Ihre Anwendungen 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 zu Fehlercodes an. Falls Sie noch Fragen haben, können Sie diese auf Stack Overflow mit dem Tag #SecEvents posten.