Ochrona kont użytkowników za pomocą Ochrony wszystkich kont

Jeśli Twoja aplikacja umożliwia użytkownikom logowanie się na konta przez Google, możesz: bezpieczeństwo użytkowników, których współdzielą kont, nasłuchując i odpowiadając powiadomień o zdarzeniach związanych z bezpieczeństwem udostępnianych przez usługę ochrony wszystkich kont.

Powiadomienia te informują o ważnych zmianach na Twoim koncie Google użytkowników, co często może mieć wpływ na bezpieczeństwo ich kont, do aplikacji. Jeśli na przykład ktoś włamie się na konto Google, potencjalnie dopuścić do włamania na konto użytkownika powiązanego z Twoją aplikacją e-mailem. odzyskiwania konta i korzystania z logowania jednokrotnego.

Aby pomóc Ci zmniejszyć ryzyko wystąpienia takich zdarzeń, Google wysyła Twoją obiektów usługi nazywanych tokenami zdarzeń związanych z bezpieczeństwem. Te tokeny ujawniają bardzo mało informacje – tylko typ zdarzenia związanego z bezpieczeństwem i czas jego wystąpienia, a także użytkownika, którego dotyczy problem, ale możesz go użyć, odpowiednie działania w odpowiedzi. Jeśli na przykład konto Google użytkownika zostało przejętego, możesz tymczasowo wyłączyć funkcję Zaloguj się przez Google dla tego użytkownika oraz zapobiega wysyłaniu e-maili dotyczących odzyskiwania konta na adres Gmail użytkownika.

Ochrona wszystkich kont opiera się na standard RISC opracowany w OpenID Foundation.

Omówienie

Aby korzystać z Ochrony wszystkich kont w swojej aplikacji lub usłudze, musisz wykonać następujące zadania:

1. Skonfiguruj projekt w: API Console.

2. Utwórz punkt końcowy odbiorcy zdarzeń, do którego Google będzie wysyłać zdarzenie związane z bezpieczeństwem tokeny. Ten punkt końcowy odpowiada za weryfikację otrzymanych tokenów a następnie reagować na zdarzenia związane z bezpieczeństwem w dowolny sposób.

3. Aby zacząć otrzymywać tokeny zdarzeń związanych z bezpieczeństwem, zarejestruj punkt końcowy w Google.

Warunek wstępny

Tokeny zdarzeń związanych z bezpieczeństwem otrzymasz tylko w przypadku użytkowników Google, którzy udzielili dostępu do informacji profilowych lub adresów e-mail użytkowników. Ty uzyskać to uprawnienie, wysyłając żądanie o zakresy profile lub email. Nowsza Zaloguj się przez Google lub starszą wersję aplikacji, Pakiety SDK logowania przez Google domyślnie żądają tych zakresów, ale jeśli nie używasz ustawień domyślnych lub korzystasz z identyfikatora OpenID Google Połącz punkt końcowy bezpośrednio. Sprawdź, wysyłasz żądanie co najmniej 1 z tych zakresów.

Skonfiguruj projekt w API Console

Zanim zaczniesz otrzymywać tokeny zdarzeń związanych z bezpieczeństwem, musisz utworzyć usługę i włącz interfejs RISC API w API Console . Musisz użyć tego samego API Console projekt, którego używasz usług Google, takich jak Logowanie przez Google, w Twojej aplikacji.

Aby utworzyć konto usługi:

1. Otwórz API Console Credentials page. Gdy pojawi się odpowiedni komunikat, wybierz API Console projektu, którego używasz do uzyskiwania dostępu do usług Google w swojej aplikacji.

2. Kliknij Utwórz dane logowania > Konto usługi.

3. Utwórz nowe konto usługi z rolą administratora konfiguracji RISC (roles/riscconfigs.admin) przez obserwowanie tymi instrukcjami.

4. Utwórz klucz dla nowo utworzonego konta usługi. Wybierz klucz JSON i kliknij Utwórz. Podczas tworzenia klucza pobierzesz plik JSON zawierający Twoje konto usługi, dane logowania. Przechowuj ten plik w bezpiecznym miejscu, ale ma też dostęp do: punktu końcowego odbiorcy zdarzeń.

Będąc w projekcie, zanotuj też nazwę klienta. Identyfikatory, których używasz na potrzeby funkcji Zaloguj się przez Google lub Logowanie przez Google (starsza wersja). Zwykle dla każdej aplikacji jest podany identyfikator klienta platformy, w której się uczysz. Te identyfikatory klientów będą potrzebne do weryfikacji zdarzenia związanego z bezpieczeństwem tokeny, jak opisano w następnej sekcji.

Aby włączyć interfejs RISC API:

1. Otwórz stronę RISC API w API ConsoleSprawdź, czy używany przez Ciebie projekt aby uzyskać dostęp do usług Google.

2. Przeczytaj Warunki RISC i upewnij się, że rozumiesz wymagania.

   Jeśli włączasz interfejs API w projekcie należącym do organizacji, sprawdź, masz upoważnienie do związania swojej organizacji Warunkami RISC.

3. Kliknij Włącz tylko wtedy, gdy wyrażasz zgodę na Warunki RISC.

Tworzenie punktu końcowego odbiorcy zdarzeń

Aby otrzymywać od Google powiadomienia o zdarzeniach związanych z bezpieczeństwem, utwórz punkt końcowy HTTPS który obsługuje żądania HTTPS POST. Po zarejestrowaniu tego punktu końcowego (patrz poniżej) Google zacznie publikować podpisane kryptograficznie ciągi znaków nazywane zdarzeniem bezpieczeństwa tokeny w punkcie końcowym. Tokeny zdarzeń zabezpieczeń to podpisane tokeny JWT, które zawierają informacji na temat pojedynczego zdarzenia związanego z bezpieczeństwem.

W przypadku każdego tokena zdarzenia związanego z bezpieczeństwem otrzymanego w punkcie końcowym najpierw zweryfikuj zdekodować token, a następnie obsługiwać zdarzenie związane z bezpieczeństwem odpowiednio posprzedażna. Konieczne jest zweryfikowanie tokena zdarzenia przed dekodowaniem, aby zapobiec złośliwe ataki ze strony nieuczciwych podmiotów. Zadania te są opisane w sekcjach poniżej:

1. Dekodowanie i weryfikowanie tokena zdarzenia związanego z bezpieczeństwem

Tokeny zdarzeń zabezpieczeń to specjalny rodzaj tokenów JWT, więc możesz używać dowolnego biblioteka JWT, np. wymieniona na jwt.io, do dekodowania i ich potwierdzenie. Niezależnie od używanej biblioteki, kod weryfikacyjny tokena musi wykonać :

1. Pobieranie identyfikatora wydawcy Ochrony wszystkich kont (issuer) i klucza podpisywania identyfikator URI certyfikatu (jwks_uri) z dokumentu konfiguracji RISC od Google, które znajdziesz na https://accounts.google.com/.well-known/risc-configuration
2. Korzystając z wybranej biblioteki JWT, pobierz identyfikator klucza podpisywania z nagłówka tokena zdarzenia związanego z bezpieczeństwem.
3. Z dokumentu certyfikatu klucza podpisywania Google pobierz klucz publiczny z identyfikatora klucza uzyskany w poprzednim kroku. Jeśli dokument nie zawiera klucza o identyfikatorze, którego szukasz, prawdopodobnie token zdarzenia związanego z bezpieczeństwem jest nieprawidłowy i punkt końcowy powinien zwracać błąd HTTP 400.
4. Korzystając z wybranej biblioteki JWT, sprawdź, czy:
   • Token zdarzenia związanego z bezpieczeństwem jest podpisany za pomocą klucza publicznego uzyskanego w poprzedniego kroku.
   • Deklaracja aud tokena jest jedną z Twoich aplikacji identyfikatorów klientów.
   • Deklaracja iss tokena pasuje do identyfikatora wydawcy, od którego uzyskano dostęp dokument opisujący RISC. Nie musisz weryfikować daty ważności tokena (exp), ponieważ Tokeny zdarzeń związanych z bezpieczeństwem reprezentują zdarzenia historyczne, więc nie wygasają.

Na przykład:

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)

Jeśli token jest prawidłowy i został zdekodowany, zwracaj stan HTTP 202. Następnie przetwórz zdarzenie związane z bezpieczeństwem wskazane przez token.

2. Obsługa zdarzeń związanych z bezpieczeństwem

Po zdekodowaniu token zdarzenia związanego z bezpieczeństwem wygląda tak:

{
  "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"
    }
  }
}

Deklaracje iss i aud wskazują wystawcę tokena (Google) i tag docelowego odbiorcy tokena (Twojej usługi). Te roszczenia zostały przez Ciebie zweryfikowane w poprzedniego kroku.

Deklaracja jti to ciąg znaków, który identyfikuje pojedyncze zdarzenie związane z bezpieczeństwem. tylko w przypadku danego strumienia. Możesz użyć tego identyfikatora do śledzenia, które zdarzenia związane z bezpieczeństwem otrzymanych przez Ciebie.

Deklaracja events zawiera informacje o zdarzeniu związanym z bezpieczeństwem tokena co reprezentuje. Ta rezerwacja to mapowanie z identyfikatora typu zdarzenia na subject twierdzenia, które wskazuje użytkownika, którego dotyczy to zdarzenie, oraz do wszelkich dodatkowych szczegóły wydarzenia, które mogą być dostępne.

Deklaracja subject identyfikuje konkretnego użytkownika za pomocą jego unikalnego identyfikatora Google Identyfikator konta (sub). Ten identyfikator konta Google jest identycznym z identyfikatorem (sub) podanym w tabeli w tokenach identyfikatora JWT wystawionych przez nowszą funkcję Zaloguj się przez Google (JavaScript , biblioteki HTML), starszą bibliotekę Logowanie przez Google lub OpenID Connect. Gdy w tagu subject_type twierdzenie to id_token_claims, może też zawierać pole email z adres e-mail użytkownika.

Użyj informacji z roszczenia events, aby podjąć odpowiednie działania w odniesieniu do na koncie określonego użytkownika.

Identyfikatory tokenów OAuth

W przypadku zdarzeń OAuth dotyczących poszczególnych tokenów typ identyfikatora tematu tokena zawiera te pola:

• token_type: obsługiwana jest tylko wartość refresh_token.

• token_identifier_alg: możliwe wartości znajdziesz w tabeli poniżej.

• token: patrz tabela poniżej.

Jeśli przeprowadzisz integrację z tymi zdarzeniami, zalecamy indeksowanie tokenów na podstawie tych możliwych wartości, aby zapewnić szybkie dopasowanie po otrzymaniu zdarzenia.

Obsługiwane typy zdarzeń

Ochrona wszystkich kont obsługuje te typy zdarzeń związanych z bezpieczeństwem:

Zduplikowane i pominięte wydarzenia

Ochrona wszystkich kont będzie próbowała ponownie przesłać zdarzenia, które według jej prognozy nie dostarczono. Dlatego czasami to samo zdarzenie wiele razy. Jeśli spowoduje to powtarzające się działania, które w efekcie użytkowników, możesz użyć deklaracji jti (która jest unikalnym identyfikatorem ), aby usunąć duplikaty zdarzeń. Są to narzędzia zewnętrzne, takie jak Google Cloud Dataflow, która może ułatwić wykonanie do usuwania duplikatów w Dataflow.

Pamiętaj, że wydarzenia są dostarczane z ograniczoną liczbą ponownych prób, więc jeśli odbiornik jest niedostępny. przez dłuższy czas możesz trwale przegapić niektóre wydarzenia.

Zarejestruj odbiornik

Aby zacząć odbierać zdarzenia związane z bezpieczeństwem, zarejestruj punkt końcowy odbiorcy za pomocą RISC API. Wywołaniom do interfejsu RISC API musi towarzyszyć token autoryzacji.

Będziesz otrzymywać zdarzenia związane z bezpieczeństwem tylko dla użytkowników Twojej aplikacji, dlatego musisz skonfigurować ekran zgody OAuth w projekcie GCP. Jest to wymagane do wykonania kroków opisanych poniżej.

1. Generowanie tokena autoryzacji

Aby wygenerować token autoryzacji dla interfejsu RISC API, utwórz token JWT z następujące stwierdzenia:

{
  "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
}

Podpisz JWT za pomocą klucza prywatnego konta usługi, który znajdziesz w Plik JSON pobrany podczas tworzenia klucza konta usługi.

Na przykład:

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

Ten token autoryzacji może być używany do wywoływania interfejsu RISC API przez 1 godzinę. Kiedy token wygaśnie, wygeneruj nowy, aby nadal wykonywać wywołania interfejsu RISC API.

2. Wywoływanie interfejsu API konfiguracji strumienia RISC

Teraz gdy masz już token autoryzacji, możesz użyć interfejsu RISC API, aby skonfigurować strumienia zdarzeń związanych z bezpieczeństwem projektu, w tym rejestrowania odbiornika punktu końcowego.

Aby to zrobić, wyślij żądanie HTTPS POST do https://risc.googleapis.com/v1beta/stream:update, określenie punktu końcowego odbiorcy i typów zabezpieczeń, wydarzenia, które Cię interesują:

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

Na przykład:

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'])

Jeśli żądanie zwraca kod HTTP 200, oznacza to, że strumień zdarzeń został skonfigurowany. a punkt końcowy odbiorcy powinien zacząć otrzymywać tokeny zdarzeń związanych z bezpieczeństwem. następna sekcja opisuje, jak przetestować konfigurację strumienia i punkt końcowy. aby sprawdzić, czy wszystko działa poprawnie.

Pobieranie i aktualizowanie bieżącej konfiguracji strumienia

Jeśli w przyszłości zechcesz zmienić konfigurację transmisji, więc wysyłając autoryzowane żądanie GET do usługi https://risc.googleapis.com/v1beta/stream, bieżącą konfigurację strumienia, zmodyfikować treść odpowiedzi, a następnie wysłać z powrotem zmodyfikowano konfigurację do https://risc.googleapis.com/v1beta/stream:update w sposób opisany powyżej.

Zatrzymywanie i wznawianie transmisji wydarzenia

Jeśli kiedykolwiek zechcesz zatrzymać strumień wydarzeń z Google, wykonaj autoryzowane żądanie POST prośba do: https://risc.googleapis.com/v1beta/stream/status:update za pomocą: { "status": "disabled" } w treści żądania. Gdy strumień jest dezaktywowany, Google nie wysyła zdarzeń do punktu końcowego i nie buforuje zdarzeń związanych z bezpieczeństwem, gdy wystąpią. Do ponownie włącz strumień zdarzeń, POST { "status": "enabled" } w tym samym punkcie końcowym.

3. Opcjonalnie: testowanie konfiguracji strumienia

Możesz sprawdzić, czy konfiguracja strumienia i punkt końcowy odbiorcy działają poprawnie, wysyłając token weryfikacyjny w strumieniu zdarzeń. Może on zawierać unikalny ciąg znaków, za pomocą którego można sprawdzić, czy odebrano token w punkcie końcowym. Aby skorzystać z tej procedury, zasubskrybuj https://schemas.openid.net/secevent/risc/event-type/verification typ zdarzenia podczas rejestrowania odbiornika.

Aby poprosić o token weryfikacyjny, wyślij autoryzowane żądanie HTTPS POST do https://risc.googleapis.com/v1beta/stream:verify W treści żądania określ ciąg identyfikujący:

{
  "state": "ANYTHING"
}

Na przykład:

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

Jeśli żądanie się powiedzie, token weryfikacyjny zostanie wysłany do punktu końcowego zarejestrowano. Następnie, jeśli punkt końcowy obsługuje tokeny weryfikacyjne przez można sprawdzić w dziennikach, czy token odebrane.

Odniesienie do kodu błędu

Interfejs RISC API może zwrócić te błędy:

Zakresy tokenów dostępu

Jeśli zdecydujesz się używać tokenów dostępu do uwierzytelniania w interfejsie RISC API, to zakresy, do których aplikacja musi prosić:

Potrzebujesz pomocy?

Najpierw zapoznaj się z informacjami o kodach błędów. Jeśli nadal ma pytania, publikuj je na Stack Overflow #SecEvents .