Nutzerkonten mit dem produktübergreifenden Kontoschutz schützen

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:

1. Richten Sie Ihr Projekt in der API Consoleein.

2. 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.

3. 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 API Consoleeinrichten

Bevor Sie Tokens für Sicherheitsereignisse erhalten können, müssen Sie einen Dienst erstellen und aktivieren Sie die RISC API in Ihrem API Console -Projekt erstellen. Sie müssen die gleichen API Console Projekt, mit dem Sie zugreifen Google-Dienste wie Google Log-in in Ihrer App

So erstellen Sie das Dienstkonto:

1. Öffnen Sie das API Console Credentials page Wenn Sie dazu aufgefordert werden, wählen Sie API Console Projekt, mit dem Sie in Ihrer App auf Google-Dienste zugreifen.

2. Klicken Sie auf Anmeldedaten erstellen > Dienstkonto.

3. Neues Dienstkonto mit der Rolle „RISC-Konfigurationsadministrator“ erstellen (roles/riscconfigs.admin) indem Sie dieser Anleitung.

4. 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:

1. Öffnen Sie die RISC API-Seite im API ConsoleAchten Sie darauf, dass das Projekt, für den Zugriff auf Google-Dienste ist immer noch ausgewählt.

2. 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.

3. 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:

1. Aussteller-ID des produktübergreifenden Kontoschutzes (issuer) und Signaturschlüssel abrufen Zertifikats-URI (jwks_uri) aus dem RISC-Konfigurationsdokument von Google, Sie finden diese unter https://accounts.google.com/.well-known/risc-configuration
2. Verwende die JWT-Bibliothek deiner Wahl, um die Signaturschlüssel-ID aus dem Header abzurufen des Sicherheitsereignistokens.
3. 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.
4. 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:

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;
}

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, 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: Nur refresh_token wird unterstützt.

• token_identifier_alg: Mögliche Werte finden Sie in der Tabelle unten.

• token: Siehe Tabelle unten.

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:

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:

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;
}

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:

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);

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:

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);

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:

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:

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.