Wenn deine App es Nutzern ermöglicht, sich über Google in ihren Konten anzumelden, kannst du die Funktionen verbessern die Sicherheit dieser freigegebenen Nutzer indem Sie auf die Reaktionen vom produktübergreifenden Kontoschutz bereitgestellt werden.
Diese Benachrichtigungen informieren Sie über wichtige Änderungen an den Google-Konten Ihres Dies kann häufig auch Auswirkungen auf die Sicherheit von Konten mit für Ihre App. Wenn beispielsweise das Google-Konto eines Nutzers gehackt wurde, das Konto des Nutzers bei Ihrer App per E-Mail gefährden kann Kontowiederherstellung oder die Einmalanmeldung (SSO) verwenden.
Um das Risikopotenzial solcher Ereignisse zu mindern, sendet Google Ihre Dienstobjekte, die als Tokens für Sicherheitsereignisse bezeichnet werden. Diese Tokens decken nur sehr wenige die Art des Sicherheitsereignisses und den Zeitpunkt des Auftretens sowie Kennung des betroffenen Nutzers. Sie können sie jedoch verwenden, um angemessene Maßnahme ergreifen. Wenn das Google-Konto eines Nutzers könnten Sie „Über Google anmelden“ vorübergehend für diesen Nutzer deaktivieren und Verhindern, dass E-Mails zur Kontowiederherstellung an die Gmail-Adresse des Nutzers gesendet werden.
Der produktübergreifende Kontoschutz basiert auf den RISC-Standard, entwickelt im OpenID Foundation
Übersicht
Wenn Sie den produktübergreifenden Kontoschutz mit Ihrer App oder Ihrem Dienst verwenden möchten, müssen Sie folgende Aufgaben ausführen:
Richten Sie Ihr Projekt in der ein.
Endpunkt für Ereignisempfänger erstellen, an den Google ein Sicherheitsereignis sendet Tokens. Dieser Endpunkt ist für die Validierung der erhaltenen Tokens verantwortlich und auf Sicherheitsvorfälle zu reagieren, wie du es vorhast.
Registrieren Sie Ihren Endpunkt bei Google, um Sicherheitsereignistokens zu erhalten.
Vorbereitung
Sie erhalten nur Tokens für Sicherheitsereignisse für Google-Nutzer, die Ihre
die Berechtigung des Dienstes, auf ihre Profilinformationen oder E-Mail-Adressen zuzugreifen. Ich
Fordern Sie die Berechtigung profile oder email an, um diese Berechtigung zu erhalten. Das neuere
Über Google anmelden oder die alte Version
Google Log-in SDKs fordern diese Bereiche standardmäßig an, aber
wenn Sie nicht die Standardeinstellungen verwenden oder auf die OpenID von Google
Endpunkt direkt verbinden, achten Sie darauf,
Sie fordern mindestens einen dieser Bereiche an.
Projekt in der einrichten
Bevor Sie Tokens für Sicherheitsereignisse erhalten können, müssen Sie einen Dienst erstellen und aktivieren Sie die RISC API in Ihrem -Projekt erstellen. Sie müssen die gleichen Projekt, mit dem Sie zugreifen Google-Dienste wie Google Log-in in Ihrer App
So erstellen Sie das Dienstkonto:
Öffnen Sie das Wenn Sie dazu aufgefordert werden, wählen Sie Projekt, mit dem Sie in Ihrer App auf Google-Dienste zugreifen.
Klicken Sie auf Anmeldedaten erstellen > Dienstkonto.
Neues Dienstkonto mit der Rolle „RISC-Konfigurationsadministrator“ erstellen (
roles/riscconfigs.admin) indem Sie dieser Anleitung.Erstellen Sie einen Schlüssel für das neu erstellte Dienstkonto. JSON-Schlüssel auswählen tippen und dann auf Erstellen klicken. Wenn der Schlüssel erstellt wird, laden Sie eine JSON-Datei herunter, die Ihr Dienstkonto enthält. Anmeldedaten. Bewahren Sie diese Datei an einem sicheren Ort auf, aber auch für Ihren Endpunkt des Ereignisempfängers.
Notieren Sie sich auf der Seite „Anmeldedaten“ Ihres Projekts den Client IDs, die Sie für „Über Google anmelden“ oder „Google Log-in“ (alte Version) verwenden. Normalerweise haben Sie für jede die Sie unterstützen. Sie benötigen diese Client-IDs, um das Sicherheitsereignis zu validieren -Tokens, wie im nächsten Abschnitt beschrieben.
So aktivieren Sie die RISC API:
Öffnen Sie die RISC API-Seite im Achten Sie darauf, dass das Projekt, für den Zugriff auf Google-Dienste ist immer noch ausgewählt.
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, achten Sie darauf, Sie sind autorisiert, Ihre Organisation an die RISC-Nutzungsbedingungen zu binden.
Klicken Sie nur 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 das HTTPS POST-Anfragen verarbeitet. Nachdem Sie diesen Endpunkt registriert haben (siehe unten), Google beginnt damit, kryptografisch signierte Strings zu veröffentlichen, die als „Sicherheitsereignisse“ bezeichnet werden an den Endpunkt zu senden. Sicherheitsereignistokens sind signierte JWTs, die Informationen zu einem einzelnen sicherheitsrelevanten Ereignis.
Validieren und prüfen Sie jedes Sicherheitsereignistoken, das Sie an Ihrem Endpunkt erhalten. decodieren Sie das Token und behandeln Sie das Sicherheitsereignis entsprechend Ihrem . Es ist wichtig, das Ereignistoken vor der Decodierung zu validieren, um zu verhindern, bösartigen Angriffen helfen. In den folgenden Abschnitten werden diese Aufgaben beschrieben:
1. Sicherheitsereignistoken decodieren und validieren
Da Tokens für Sicherheitsereignisse eine spezielle Art von JWT sind, können Sie beliebige JWT-Bibliothek, wie z. B. eine in jwt.io aufgeführte, zum Decodieren und um sie zu validieren. Unabhängig von der verwendeten Bibliothek muss Ihr Token-Validierungscode die Folgendes:
- Aussteller-ID des produktübergreifenden Kontoschutzes (
issuer) und Signaturschlüssel abrufen Zertifikats-URI (jwks_uri) aus dem RISC-Konfigurationsdokument von Google, Sie finden diese unterhttps://accounts.google.com/.well-known/risc-configuration - Verwende die JWT-Bibliothek deiner Wahl, um die Signaturschlüssel-ID aus dem Header abzurufen des Sicherheitsereignistokens.
- Rufen Sie aus dem Signaturdokument von Google den öffentlichen Schlüssel mit der Schlüssel-ID aus dem vorherigen Schritt. Wenn das Dokument keinen Schlüssel enthält mit der gesuchten ID hat, ist das Sicherheitsereignis-Token wahrscheinlich ungültig ist und der Endpunkt den HTTP-Fehler 400 zurückgeben sollte.
- Prüfen Sie mithilfe der JWT-Bibliothek Ihrer Wahl Folgendes:
<ph type="x-smartling-placeholder">
- </ph>
- Das Sicherheitsereignistoken wird mit dem öffentlichen Schlüssel signiert, den Sie im vorherigen Schritt.
- Die
aud-Anforderung des Tokens ist eine Ihrer Apps Client-IDs. - Die
iss-Anforderung des Tokens stimmt mit der Aussteller-ID überein, die Sie von im RISC-Discovery-Dokument. Sie müssen den Ablauf des Tokens (exp) nicht überprüfen, da Token für Sicherheitsereignisse stellen historische Ereignisse dar und laufen daher nicht ab.
Beispiel:
Java
java-jwt verwenden 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, wird der HTTP-Status 202 zurückgegeben. Verarbeiten Sie dann das durch das Token angegebene Sicherheitsereignis.
2. Umgang mit Sicherheitsereignissen
Nach der Decodierung sieht ein Sicherheitsereignistoken wie das folgende 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 Anforderungen iss und aud geben den Aussteller des Tokens (Google) und den
an den für das Token vorgesehenen Empfänger (Ihr Dienst). Sie haben diese Ansprüche bestätigt in:
vorherigen Schritt.
Die jti-Anforderung ist ein String, der ein einzelnes Sicherheitsereignis identifiziert. Sie ist
nur für den Stream. Mit dieser Kennung können Sie erfassen,
die Sie erhalten haben.
Die Anforderung events enthält Informationen zum Sicherheitsereignis, das das Token enthält.
dargestellt wird. Dieser Anspruch ist eine Zuordnung von einer Ereignistyp-ID zu einer subject.
Anforderung, die den Nutzer angibt, auf den sich dieses Ereignis bezieht, sowie alle weiteren
Details zur Veranstaltung,
die verfügbar sein könnten.
Die subject-Anforderung identifiziert einen bestimmten Nutzer anhand des eindeutigen Google-Elements dieses Nutzers
Konto-ID (sub) Diese Google-Konto-ID ist mit der Kennung (sub) identisch
in den JWT-ID-Tokens, die vom neueren „Über Google anmelden“ ausgestellt wurden (JavaScript
, HTML-Bibliothek, alte Google Log-in-Bibliothek oder
OpenID Connect. Wenn die subject_type des
Anforderung id_token_claims lautet, kann auch das Feld email mit dem Parameter
E-Mail-Adresse des Nutzers.
Nutze die Informationen in dem events-Anspruch, um geeignete Maßnahmen für den
Ereignistyp des angegebenen Nutzerkontos.
OAuth-Token-IDs
Bei OAuth-Ereignissen zu einzelnen Tokens enthält der Kennungstyp Tokensubjekt 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. |
Bei der Einbindung dieser Ereignisse wird empfohlen, Ihre Tokens basierend auf für diese möglichen Werte, um eine schnelle Übereinstimmung beim Empfang des Ereignisses sicherzustellen.
Unterstützte Ereignistypen
Der produktübergreifende Kontoschutz unterstützt die folgenden Arten von Sicherheitsereignissen:
| Ereignistyp | Attribute | Antworten |
|---|---|---|
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked |
Erforderlich: Schützen Sie das Konto des Nutzers wieder, indem Sie seine aktuelle offenen Sitzungen. | |
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked |
Erforderlich: Wenn das Token für Google Log-in bestimmt ist, kündigen Sie derzeit geöffnete Sitzungen. Außerdem sollten Sie dem Nutzer vorschlagen, eine alternative Anmeldemethode einzurichten. Vorgeschlagen: Wenn das Token für den Zugriff auf andere Google APIs bestimmt ist, löschen Sie eines der von Ihnen gespeicherten OAuth-Tokens des Nutzers. |
|
https://schemas.openid.net/secevent/oauth/event-type/token-revoked |
Im Abschnitt OAuth-Token-IDs finden Sie weitere Informationen dazu, Token-IDs |
Erforderlich: Wenn Sie das entsprechende Aktualisierungstoken speichern, löschen Sie es. und den Nutzer um seine Einwilligung bitten, wenn er das nächste Mal ein Zugriffstoken benötigt. |
https://schemas.openid.net/secevent/risc/event-type/account-disabled |
reason=hijacking,reason=bulk-account |
Erforderlich: Wenn der Grund für die Kontodeaktivierung war
Vorgeschlagen: Falls der Grund für die Kontodeaktivierung
Empfohlen: Wenn Sie keinen Grund angegeben haben, deaktivieren Sie Google Log-in für die deaktiviert und die Kontowiederherstellung mit der E-Mail-Adresse, die mit Das Google-Konto des Nutzers (normalerweise, aber nicht unbedingt ein Gmail-Konto) Bieten Sie dem Nutzer eine alternative Anmeldemethode an. |
https://schemas.openid.net/secevent/risc/event-type/account-enabled |
Vorgeschlagen: Aktivieren Sie Google Log-in für den Nutzer und danach wieder. Kontowiederherstellung über die E-Mail-Adresse des Google-Kontos des Nutzers. | |
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required |
Vorgeschlagen: Achten Sie auf verdächtige Aktivitäten in Ihrem Dienst und nehmen Sie angemessene Maßnahme ergreifen. | |
https://schemas.openid.net/secevent/risc/event-type/verification |
state=state | Vorgeschlagen: Es wird protokolliert, dass ein Testtoken empfangen wurde. |
Duplizierte und verpasste Termine
Der produktübergreifende Kontoschutz versucht, Ereignisse noch einmal zu senden, die seiner Meinung nach
nicht zugestellt. Daher kann es vorkommen, dass
und zwar mehrmals. Wenn dies zu wiederholten Aktionen führen kann, durch die Ihr
Nutzer verwenden, sollten Sie die jti-Anforderung verwenden. Dabei handelt es sich um eine eindeutige Kennung für
, um doppelte Einträge zu entfernen. Es gibt externe Tools wie Google Cloud
Dataflow, das Ihnen bei der Ausführung
de-dup-Datenfluss.
Ereignisse werden mit begrenzten Wiederholungsversuchen übermittelt. Wenn der Empfänger ausgefallen ist, über einen längeren Zeitraum hinweg könnten Sie einige Termine dauerhaft verpassen.
Empfänger registrieren
Registrieren Sie den Empfängerendpunkt über die RISC API. Für Aufrufe der RISC API muss ein Autorisierungstoken angegeben werden.
Sie erhalten Sicherheitsereignisse nur für die Nutzer Ihrer App, daher muss ein OAuth-Zustimmungsbildschirm konfiguriert sein in Ihrem GCP-Projekt als Voraussetzung für die unten beschriebenen Schritte.
1. Autorisierungstoken generieren
Um ein Autorisierungstoken für die RISC API zu generieren, erstellen Sie ein JWT mit der folgende Ansprüche:
{
"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
}Signiere das JWT mit dem privaten Schlüssel deines Dienstkontos, den du in der JSON-Datei, die Sie beim Erstellen des Dienstkontoschlüssels heruntergeladen haben.
Beispiel:
Java
java-jwt und 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 eine Stunde lang für RISC API-Aufrufe verwendet werden. Wann? Das Token läuft ab. Generieren Sie ein neues, um weiterhin RISC API-Aufrufe ausführen zu können.
2. RISC-Stream-Konfigurations-API aufrufen
Da Sie jetzt ein Autorisierungstoken haben, können Sie die RISC API zur Konfiguration Sicherheitsereignisstream Ihres Projekts, einschließlich der Registrierung Ihres Empfängers Endpunkt.
Stellen Sie dazu eine HTTPS-POST-Anfrage an https://risc.googleapis.com/v1beta/stream:update,
Angabe des Empfängerendpunkts und der Sicherheitstypen
Events, 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 den HTTP-Statuscode 200 zurückgibt, wurde der Ereignisstream erfolgreich konfiguriert. und der Empfängerendpunkt sollte Sicherheitsereignistokens empfangen. Die Im nächsten Abschnitt wird beschrieben, wie Sie die Streamkonfiguration und den Endpunkt testen können. um zu überprüfen, ob alles ordnungsgemäß funktioniert.
Aktuelle Streamkonfiguration abrufen und aktualisieren
Wenn Sie die Streamkonfiguration in Zukunft ändern möchten, haben Sie folgende Möglichkeiten:
Stellen Sie also eine autorisierte GET-Anfrage an https://risc.googleapis.com/v1beta/stream, um den
aktuelle Streamkonfiguration, das Ändern des Antworttexts und anschließendes Senden der
geänderte Konfiguration zurück zu https://risc.googleapis.com/v1beta/stream:update, wie oben beschrieben.
Ereignisstream beenden und fortsetzen
Wenn Sie den Ereignis-Stream von Google anhalten müssen, führen Sie eine autorisierte POST-Anfrage
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 den Endpunkt an.
Sicherheitsereignisse werden nicht gepuffert, wenn sie auftreten. Bis
Reaktivieren Sie den Ereignisstream, POST { "status": "enabled" } an denselben Endpunkt.
3. Optional: Streamkonfiguration testen
Du kannst prüfen, ob die Streamkonfiguration und der Empfängerendpunkt funktionieren zusammen, indem du ein Bestätigungstoken über deinen Ereignis-Stream sendest. Dieses Token kann einen eindeutigen String enthalten, mit dem Sie prüfen können, ob das Token Token wurde an Ihrem Endpunkt empfangen. Um diesen Ablauf zu verwenden, https://schemas.openid.net/secevent/risc/event-type/verification abonnieren wenn Sie den Empfänger registrieren.
Um ein Bestätigungstoken anzufordern, senden Sie eine autorisierte HTTPS-POST-Anfrage an
https://risc.googleapis.com/v1beta/stream:verify Geben Sie im Text der Anfrage einige
Zeichenfolge zur Identifizierung:
{
"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 Endpunkt gesendet, registriert. Wenn Ihr Endpunkt beispielsweise Bestätigungstokens über einfach protokollieren, können Sie Ihre Logs überprüfen, um zu bestätigen, erhalten haben.
Fehlercode-Referenz
Die folgenden Fehler können von der RISC API zurückgegeben werden:
| 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. Bitte geben Sie in Ihrer Anfrage $fieldname an. |
| 401 | Nicht autorisiert. | Fehler bei der Autorisierung Achten Sie darauf, dass Sie eine Autorisierungstoken mit der Anfrage und dass das Token gültig ist. und dürfen noch nicht abgelaufen sein. |
| 403 | Der Bereitstellungsendpunkt muss eine HTTPS-URL sein. | Ihren Zustellungsendpunkt (d.h. der Endpunkt, von dem Sie erwarten, dass RISC-Ereignisse vorhanden sind) bereitgestellt werden) muss HTTPS sein. Wir senden keine RISC-Ereignisse an HTTP-URLs. |
| 403 | Die vorhandene Streamkonfiguration hat keine spezifikationskonforme Übermittlung für RISC an. | Ihr Google Cloud-Projekt muss bereits eine RISC-Konfiguration haben. Wenn Sie Firebase verwenden und Google Log-in aktiviert haben, wird Firebase Verwaltung des RISC für Ihr Projekt können Sie kein benutzerdefiniertes Konfiguration. Wenn Sie Google Log-in nicht für Ihr Firebase-Projekt verwenden, deaktivieren Sie sie und versuchen Sie es nach einer Stunde erneut. |
| 403 | Projekt wurde nicht gefunden. | Achten Sie darauf, dass Sie das richtige Dienstkonto für den Projekt arbeiten. Möglicherweise verwenden Sie ein Dienstkonto, das mit einer gelöschten Projekt arbeiten. Weitere Informationen <ph type="x-smartling-placeholder"></ph> Wie Sie alle Dienstkonten aufrufen, die mit einem Projekt verknüpft sind |
| 403 | Dienstkonto benötigt Berechtigung für den Zugriff auf Ihre RISC Konfiguration | Gehen Sie zur Seite Ihres Projekts und
die Rolle „RISC Configuration Admin“ Rolle
(roles/riscconfigs.admin)
mit dem Dienstkonto verknüpft sind,
das die Aufrufe an Ihr Projekt sendet,
Follower
dieser Anleitung.
|
| 403 | Stream-Verwaltungs-APIs sollten nur von einem Dienstkonto aufgerufen werden. | Hier finden Sie weitere Informationen zu Wie Sie Google APIs mit einem Dienstkonto aufrufen können |
| 403 | Der Bereitstellungsendpunkt gehört zu keiner Domain Ihres Projekts. | Jedes Projekt hat eine Reihe von autorisierten Domains. Wenn Ihr Bereitstellungsendpunkt (d.h. der Endpunkt, für den Sie RISC-Ereignisse erwarten, nicht auf einem von ihnen gehostet wird, müssen Sie Domain des Endpunkts mit diesem Satz. |
| 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 Für diese Verbindung ist ein OAuth-Client erforderlich. Wenn Ihr Projekt kein OAuth hat Kundschaft finden, ist RISC wahrscheinlich nicht für Sie nützlich. Weitere Informationen zur Nutzung von OAuth durch Google für unsere APIs. |
| 403 |
Nicht unterstützter Status. Ungültiger Status |
Es werden nur die Stream-Status „enabled“ und
„disabled“. |
| 404 |
Projekt hat keine RISC-Konfiguration. Projekt hat keine vorhandene RISC-Konfiguration. 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
Sollten Sie sich für die Authentifizierung bei der RISC API mit Zugriffstokens entscheiden, sind diese sind die Bereiche, die Ihre Anwendung anfordern muss:
| 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 Fehlercode-Referenz an. Wenn Sie immer noch Fragen haben, können Sie sie auf Stack Overflow mit dem #SecEvents Tag.