Wenn Nutzer in Ihrer App sich über Google in ihren Konten anmelden können, lässt sich die Sicherheit dieser Konten verbessern, indem Sie Benachrichtigungen zu Sicherheitsereignissen des produktübergreifenden Kontoschutzes anhören und darauf reagieren.
Diese Benachrichtigungen weisen Sie auf wichtige Änderungen an den Google-Konten Ihrer Nutzer hin, die oft auch Auswirkungen auf die Sicherheit für ihre Konten bei Ihrer Anwendung haben können. Wenn beispielsweise das Google-Konto eines Nutzers gehackt wurde, kann dies zu einer Gefährdung des Nutzerkontos durch Ihre App durch E-Mail-Kontowiederherstellung oder die Verwendung der Einmalanmeldung führen.
Um das Risiko dieser Ereignisse zu minimieren, sendet Google Ihre Dienstobjekte, sogenannte Sicherheitsereignistokens. Diese Tokens enthalten nur sehr wenige Informationen – Art des Sicherheitsereignisses und Zeitpunkt des Auftretens sowie Kennung des betroffenen Nutzers. Sie können sie aber verwenden, um als Reaktion auf die Anfrage geeignete Maßnahmen zu ergreifen. Wenn beispielsweise das Google-Konto eines Nutzers manipuliert wurde, können Sie „Über Google anmelden“ für diesen Nutzer vorübergehend deaktivieren und verhindern, dass E-Mails für die 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
Führen Sie die folgenden Aufgaben aus, um den produktübergreifenden Kontoschutz für Ihre App oder Ihren Dienst zu verwenden:
Richten Sie Ihr Projekt im API Consoleein.
Erstellen Sie einen Ereignisempfängerendpunkt, an den Google Sicherheitsereignistokens sendet. Dieser Endpunkt ist dafür verantwortlich, die erhaltenen Tokens zu validieren und dann auf Sicherheitsereignisse zu reagieren, wie Sie es möchten.
Registrieren Sie Ihren Endpunkt bei Google, um Sicherheitsereignistokens zu erhalten.
Voraussetzung
Sie erhalten Sicherheitsereignistokens nur für Google-Nutzer, die Ihrem Dienst die Berechtigung erteilt haben, auf ihre Profilinformationen oder E-Mail-Adressen zuzugreifen. Diese Berechtigung erhalten Sie, indem Sie die Bereiche profile oder email anfordern. Die neueren Über Google anmelden- oder Google Log-in-SDKs fordern diese Bereiche standardmäßig an. Wenn Sie 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 Sicherheitsereignistokens 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:
Öffnen Sie die API Console Credentials page. Wählen Sie bei Aufforderung dasAPI Console-Projekt aus, mit dem Sie in Ihrer Anwendung auf Google-Dienste zugreifen.
Klicken Sie auf Anmeldedaten erstellen > Dienstkonto.
Erstellen Sie gemäß dieser Anleitung ein neues Dienstkonto mit der Rolle „RISC-Konfigurationsadministrator“ (
roles/riscconfigs.admin).Erstellen Sie einen Schlüssel für das neu erstellte Dienstkonto. Wählen Sie den JSON-Schlüsseltyp aus und klicken Sie auf Erstellen. Beim Erstellen des Schlüssels laden Sie eine JSON-Datei mit den Anmeldedaten Ihres Dienstkontos herunter. Speichern Sie diese Datei an einem sicheren Ort, aber auch für den Endpunkt des Ereignisempfängers.
Notieren Sie sich auf der Seite „Anmeldedaten“ Ihres Projekts die Client-IDs, die Sie für „Über Google anmelden“ oder „Google Log-in (alt)“ verwenden. In der Regel haben Sie eine Client-ID für jede unterstützte Plattform. Sie benötigen diese Client-IDs, um Sicherheitsereignistokens wie im nächsten Abschnitt beschrieben zu validieren.
So aktivieren Sie die RISC API:
Ö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.
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, sollten Sie prüfen, ob Sie berechtigt sind, Ihre Organisation an die RISC-Nutzungsbedingungen zu binden.
Klicken Sie nur dann auf Aktivieren, wenn Sie den RISC-Nutzungsbedingungen zustimmen.
Endpunkt für Ereignisempfänger 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 mit dem Veröffentlichen von kryptografisch signierten Strings, die als Sicherheitsereignistokens bezeichnet werden. Sicherheitsereignistokens sind JWTs, die Informationen zu einem einzelnen sicherheitsbezogenen Ereignis enthalten.
Prüfen und decodieren Sie für jedes Sicherheitsereignistoken, das Sie an Ihrem Endpunkt erhalten, zuerst das Token und verarbeiten Sie dann das Sicherheitsereignis für Ihren Dienst. Es ist unerlässlich, das Ereignistoken vor der Decodierung zu validieren, um schädliche Angriffe durch böswillige Akteuren zu verhindern. In den folgenden Abschnitten werden diese Aufgaben beschrieben:
1. Sicherheitsereignistoken decodieren und validieren
Da Sicherheitsereignistokens eine bestimmte Art von JWT sind, können Sie eine beliebige JWT-Bibliothek, z. B. eine auf jwt.io aufgelistete, verwenden, um sie zu decodieren und zu validieren. Unabhängig von der verwendeten Bibliothek muss der Token-Validierungscode Folgendes tun:
- Sie erhalten die Kennung des kontoübergreifenden Ausstellers (
issuer) und den Signaturschlüssel-Zertifikat (jwks_uri) aus dem RISC-Konfigurationsdokument von Google. Sie finden sie unterhttps://accounts.google.com/.well-known/risc-configuration. - Verwenden Sie die JWT-Bibliothek Ihrer Wahl, um die Signierschlüssel-ID aus dem Header des Sicherheitsereignistokens zu erhalten.
- Rufen Sie aus dem 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. Der Endpunkt sollte deshalb den HTTP-Fehler 400 zurückgeben.
- Prüfen Sie mit der JWT-Bibliothek Ihrer Wahl Folgendes:
- Das Sicherheitsereignistoken wird mit dem öffentlichen Schlüssel signiert, den Sie im vorherigen Schritt erhalten haben.
- Die
aud-Anforderung des Tokens ist eine der Client-IDs deiner Apps. - Die
iss-Anforderung des Tokens stimmt mit der Aussteller-ID überein, die Sie im RISC-Discovery-Dokument erhalten haben. Sie müssen die Ablaufzeit des Tokens (exp) nicht prüfen, da Sicherheitsereignistokens 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 vom Token angegebene Sicherheitsereignis.
2. Sicherheitsereignisse verarbeiten
Nach der Decodierung sieht ein Sicherheitsereignistoken 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 vorgesehenen Empfänger des Tokens (Ihren Dienst) an. Sie haben diese Behauptungen im vorherigen Schritt überprüft.
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 events-Anforderung enthält Informationen zum Sicherheitsereignis, das das Token darstellt. Dieser Anspruch ist eine Zuordnung von einer Ereignistyp-ID zu einem subject-Anspruch, der den Nutzer angibt, auf den sich dieses Ereignis bezieht, und zusätzlichen Details zum möglicherweise verfügbaren Ereignis.
Die subject-Anforderung identifiziert einen bestimmten Nutzer mit der eindeutigen Google-Konto-ID (sub). Diese Google-Konto-ID ist dieselbe ID (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 ausgegeben werden. Wenn subject_type der Anforderung id_token_claims ist, kann sie auch ein email-Feld mit der E-Mail-Adresse des Nutzers enthalten.
Anhand der Informationen im Anspruch events können Sie entsprechende Maßnahmen für den Ereignistyp im angegebenen Nutzerkonto ergreifen.
OAuth-Token-IDs
Bei OAuth-Ereignissen zu einzelnen Tokens enthält der ID-Typ Tokenobjekt die folgenden Felder:
token_type: Es wird nurrefresh_tokenunterstü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. |
Bei der Einbindung dieser Ereignisse wird empfohlen, die Tokens anhand dieser möglichen Werte zu indexieren, um eine schnelle Übereinstimmung beim Empfang des Ereignisses zu gewährleisten.
Unterstützte Ereignistypen
Der produktübergreifende Kontoschutz unterstützt die folgenden Arten von Sicherheitsereignissen:
| Ereignistyp | Attribute | So antworten Sie |
|---|---|---|
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked |
Erforderlich: Sichern Sie das Konto des Nutzers, indem Sie seine aktuell 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. Empfohlen: Wenn das Token für den Zugriff auf andere Google APIs bestimmt ist, 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, beim nächsten Zugriffstoken noch einmal die Einwilligung einzuholen. |
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 Empfohlen: Wenn der Grund für die Deaktivierung des Kontos Empfohlen: Wenn kein Grund angegeben wurde, deaktivieren Sie Google Log-in für den Nutzer und deaktivieren Sie die Kontowiederherstellung mit der E-Mail-Adresse, die mit dem Google-Konto des Nutzers verknüpft ist. In der Regel ist dies kein Gmail-Konto. Dem Nutzer eine alternative Anmeldemethode anbieten |
https://schemas.openid.net/secevent/risc/event-type/account-enabled |
Empfohlen: Aktiviere Google Log-in für den Nutzer und die Kontowiederherstellung über die E-Mail-Adresse seines Google-Kontos wieder. | |
https://schemas.openid.net/secevent/risc/event-type/account-purged |
Empfohlen: Lösche das Konto des Nutzers oder gib ihm eine alternative Anmeldemethode. | |
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: Es wird erfasst, dass ein Testtoken empfangen wurde. |
Doppelte und verpasste Ereignisse
Mit dem kontoübergreifenden Schutz wird versucht, Ereignisse noch einmal zu senden, die nicht zugestellt wurden. Daher kann es vorkommen, dass ein Ereignis mehrmals auftritt. Wenn dies wiederkehrende Aktionen verursachen kann, die für Ihre Nutzer ärgerlich sind, sollten Sie die jti-Anforderung (eine eindeutige Kennung für ein Ereignis) zum Deduplizieren der Ereignisse verwenden. Zum Erstellen des De-Dup-Dataflows können Sie externe Tools wie Google Cloud Dataflow verwenden.
Ereignisse werden mit eingeschränkten Wiederholungen geliefert. Wenn Ihr Empfänger also für einen längeren Zeitraum ausgefallen ist, fehlen unter Umständen einige Ereignisse dauerhaft.
Empfänger registrieren
Registrieren Sie den Empfängerendpunkt mithilfe der RISC API, um Sicherheitsereignisse zu empfangen. Aufrufe an die RISC API müssen von einem Autorisierungstoken begleitet werden.
Sicherheitsereignisse beziehen sich nur auf die Nutzer Ihrer App. Sie müssen daher in Ihrem GCP-Projekt einen OAuth-Zustimmungsbildschirm konfigurierenals Voraussetzung für die unten beschriebenen Schritte haben.
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
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 für eine Stunde ausgeführt werden. Generieren Sie nach Ablauf des Tokens ein neues, um weiterhin RISC API-Aufrufe auszuführen.
2. RISC-Stream-Konfigurations-API aufrufen
Nachdem Sie 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, die dich 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 der Empfängerendpunkt sollte Sicherheitsereignistokens erhalten. Im nächsten Abschnitt wird beschrieben, wie Sie die Streamkonfiguration und den Endpunkt testen können, um zu prüfen, ob alles richtig zusammen funktioniert.
Aktuelle Streamkonfiguration abrufen und aktualisieren
Wenn Sie in Zukunft die 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 dann die geänderte Konfiguration wie oben beschrieben wieder an https://risc.googleapis.com/v1beta/stream:update zu senden.
Ereignisstream beenden und fortsetzen
Wenn du den Ereignisstream von Google beenden möchtest, musst du eine entsprechende POST-Anfrage an https://risc.googleapis.com/v1beta/stream/status:update mit { "status": "disabled" } im Anfragetext senden. Während der Stream deaktiviert ist, sendet Google keine Ereignisse an Ihren Endpunkt und speichert keine Sicherheitsereignisse zwischen, wenn sie auftreten. Um den Ereignisstream wieder zu aktivieren, senden Sie { "status": "enabled" } an denselben Endpunkt.
3. Optional: Streamkonfiguration testen
Sie können prüfen, ob die Streamkonfiguration und der Empfängerendpunkt zusammen funktionieren, indem Sie über den Ereignisstream ein Bestätigungstoken senden. Dieses Token kann einen eindeutigen String enthalten, mit dem Sie prüfen können, ob das Token an Ihrem Endpunkt empfangen wurde. Wenn Sie diesen Vorgang nutzen möchten, müssen Sie beim Registrieren des Empfängers den Ereignistyp „https://schemas.openid.net/secevent/risc/event-type/verification“ abonnieren.
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 Text der Anfrage einen String zur Identifizierung 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 registrierten Endpunkt gesendet. Wenn Ihr Endpunkt 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 folgenden Fehler können von der RISC API zurückgegeben werden:
| Fehlercode | Fehlermeldung | Empfohlene Maßnahmen |
|---|---|---|
| 400 | Die Streamkonfiguration muss das Feld $fieldname enthalten. | Deine Anfrage an den Endpunkt https://risc.googleapis.com/v1beta/stream:update ist ungültig oder kann nicht geparst werden. Geben Sie in Ihrer Anfrage $fieldname an. |
| 401 | Nicht autorisiert. | Die Autorisierung ist fehlgeschlagen. Fügen Sie der Anfrage ein Autorisierungstoken hinzu und prüfen Sie, ob das Token gültig und nicht abgelaufen ist. |
| 403 | Der Bereitstellungsendpunkt muss eine HTTPS-URL sein. | Ihr Bereitstellungsendpunkt (d.h. der Endpunkt, an den Ihre RISC-Ereignisse gesendet werden sollen) muss HTTPS sein. RISC-Ereignisse werden nicht an HTTP-URLs gesendet. |
| 403 | 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 das RISC für Ihr Projekt. Sie können keine benutzerdefinierte Konfiguration erstellen. Wenn Sie Google Log-in für Ihr Firebase-Projekt nicht verwenden, deaktivieren Sie es 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. Sie verwenden möglicherweise ein Dienstkonto, das mit einem gelöschten Projekt verknüpft ist. Hier erfahren Sie, wie Sie alle mit einem Projekt verknüpften Dienstkonten aufrufen. |
| 403 | Das Dienstkonto benötigt die Berechtigung für den Zugriff auf Ihre RISC-Konfiguration | Wechseln Sie zum Projekt API Console und weisen Sie dem Dienstkonto, das die Aufrufe an Ihr Projekt ausführt, die Rolle „RISC-Konfigurationsadministrator“ (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 Bereitstellungsendpunkt gehört zu keiner Domain Ihres Projekts. | Jedes Projekt hat eine Reihe von autorisierten Domains. Wenn dein Bereitstellungs-Endpunkt (d.h. der Endpunkt, an den deine RISC-Ereignisse gesendet werden sollen) nicht auf einem dieser Hosts 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 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 für Sie nicht hilfreich. Weitere Informationen zur Nutzung von OAuth durch Google für unsere APIs. |
| 403 |
Status nicht unterstützt: Ungültiger Status |
Die Streamstatus „enabled“ und „disabled“ werden derzeit nur unterstützt. |
| 404 |
Das Projekt hat keine RISC-Konfiguration. 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. |
Zugriffstokenbereiche
Wenn Sie Zugriffstokens zur Authentifizierung bei der RISC API verwenden möchten, müssen folgende Anwendungsbereiche von der Anwendung angefordert werden:
| Endpunkt | Scope (Bereich) |
|---|---|
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 Fehlercode-Referenz an. Wenn Sie noch Fragen haben, posten Sie sie in Stack Overflow mit dem Tag #SecEvents.