Ochrona kont użytkowników za pomocą ochrony obejmującej wiele kont

Jeśli Twoja aplikacja pozwala użytkownikom logować się na swoje konta w Google, możesz zwiększyć bezpieczeństwo kont udostępnianych przez użytkowników, odpowiadając na powiadomienia o zdarzeniach związanych z bezpieczeństwem dostarczane przez usługę ochrony wszystkich kont.

Powiadomienia informują o poważnych zmianach na kontach Google Twoich użytkowników, co często ma również wpływ na bezpieczeństwo ich kont w Twojej aplikacji. Jeśli na przykład konto Google użytkownika zostało przejęte, może to być przyczyną przejęcia jego konta za pomocą funkcji odzyskiwania konta e-mail lub logowania jednokrotnego.

Aby pomóc Ci zminimalizować ryzyko takich zdarzeń, Google wysyła obiekty usługi nazywane tokenami zabezpieczeń. Tokeny te ujawniają bardzo mało informacji – tylko typ zdarzenia związanego z bezpieczeństwem oraz czas jego wystąpienia, a także identyfikator użytkownika, którego dotyczy problem. Możesz ich jednak używać do podejmowania odpowiednich działań. Jeśli na przykład konto Google zostało przejęte, możesz tymczasowo wyłączyć funkcję Zaloguj się przez Google i zapobiec wysyłaniu e-maili dotyczących odzyskiwania konta na adres Gmail użytkownika.

Ochrona wszystkich kont jest oparta na standardzie RISC opracowanym przez organizację OpenID Foundation.

Przegląd

Aby korzystać z Ochrony wszystkich kont w swojej aplikacji lub usłudze, musisz wykonać te czynności:

1. Skonfiguruj projekt w: API Console.

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

3. Zarejestruj punkt końcowy w Google, aby zacząć otrzymywać tokeny zdarzeń zabezpieczeń.

Warunek wstępny

Tokeny zdarzeń związanych z bezpieczeństwem otrzymują tylko użytkownicy Google, którzy zezwolili usłudze na dostęp do informacji o profilu lub adresów e-mail. Aby uzyskać to uprawnienie, poproś o zakresy profile lub email. Nowsze zakresy domyślnie korzystają z nowszych pakietów Sign In With Google lub starszych pakietów do logowania Google. Jeśli jednak nie korzystasz z ustawień domyślnych lub bezpośrednio uzyskujesz dostęp do punktu końcowego OpenID Connect Google, sprawdź, czy żądasz co najmniej 1 z tych zakresów.

Skonfiguruj projekt w: API Console

Zanim zaczniesz otrzymywać tokeny zdarzeń zabezpieczeń, musisz utworzyć konto usługi i włączyć interfejs RISC API w swoim projekcieAPI Console . Musisz użyć tego samegoAPI Console projektu, którego używasz do uzyskiwania dostępu do usług Google w aplikacji, takich jak Logowanie przez Google.

Aby utworzyć konto usługi:

1. Otwórz API Console Credentials page. Po wyświetleniu monitu wybierz projektAPI Console, którego używasz w aplikacji do uzyskiwania dostępu do usług Google.

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

3. Utwórz nowe konto usługi z rolą administratora konfiguracji RISC (roles/riscconfigs.admin), postępując zgodnie z tymi instrukcjami.

4. Utwórz klucz dla nowo utworzonego konta usługi. Wybierz typ klucza JSON, a następnie kliknij Utwórz. Po utworzeniu klucza pobierzesz plik JSON zawierający dane logowania do konta usługi. Przechowuj ten plik w bezpiecznym miejscu, ale także w punkcie końcowym odbiornika zdarzeń.

Będąc na stronie danych logowania w projekcie, zwróć uwagę na identyfikatory klientów, których używasz do logowania się przez Google lub logowania starszego typu. Zwykle masz identyfikator klienta dla każdej obsługiwanej platformy. Te identyfikatory klienta będą potrzebne do weryfikacji tokenów zdarzeń zabezpieczeń, jak opisano w następnej sekcji.

Aby włączyć interfejs RISC API:

1. Otwórz stronę interfejsu API RISC wAPI Console. Upewnij się, że projekt, którego używasz do uzyskiwania dostępu do usług Google, jest wciąż wybrany.

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

   Jeśli włączasz interfejs API dla projektu należącego do organizacji, sprawdź, czy masz uprawnienia do powiązania organizacji z warunkami RISC.

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

Tworzenie punktu końcowego odbiornika zdarzeń

Aby otrzymywać od Google powiadomienia o zdarzeniach związanych z bezpieczeństwem, musisz utworzyć punkt końcowy HTTPS, który obsługuje żądania HTTPS POST. Gdy zarejestrujesz ten punkt końcowy (patrz poniżej), Google zacznie publikować ciągi znaków kryptograficznie nazywane tokenami zdarzeń bezpieczeństwa. Tokeny zdarzeń zabezpieczeń są podpisanymi tokenami JWT, które zawierają informacje o pojedynczym zdarzeniu związanym z bezpieczeństwem.

W przypadku każdego tokena zdarzenia związanego z bezpieczeństwem, które otrzymujesz w punkcie końcowym, najpierw sprawdź i zdekoduj token, a następnie odpowiednio zoptymalizuj usługę, odpowiednio do potrzeb swojej usługi. Niezbędna jest weryfikacja tokena zdarzenia przed dekodowaniem, aby uniknąć złośliwych ataków. Tematy w tych sekcjach:

1. Dekodowanie i weryfikacja tokena zdarzenia dotyczącego bezpieczeństwa

Tokeny zdarzeń zabezpieczeń to specjalny rodzaj tokena JWT, dlatego możesz je zdekodować i zweryfikować za pomocą dowolnej biblioteki JWT, np. podanej na jwt.io. Niezależnie od używanej biblioteki kod weryfikacji tokena musi spełniać te warunki:

1. Pobierz identyfikator wydawcy ochrony dla wielu kont (issuer) oraz identyfikator URI certyfikatu klucza podpisywania (jwks_uri) z dokumentu konfiguracji Google RISC, który znajdziesz tutaj: https://accounts.google.com/.well-known/risc-configuration.
2. Korzystając z wybranej biblioteki JWT, uzyskaj identyfikator klucza podpisywania z nagłówka tokena zdarzenia związanego z bezpieczeństwem.
3. Z dokumentu certyfikatu klucza podpisywania Google uzyskaj klucz publiczny z identyfikatorem klucza uzyskanym w poprzednim kroku. Jeśli dokument nie zawiera klucza o identyfikatorze, którego szukasz, prawdopodobnie token zdarzenia zabezpieczeń jest nieprawidłowy, a punkt końcowy powinien zwrócić błąd HTTP 400.
4. Korzystając z wybranej biblioteki JWT, sprawdź, czy:
   • Token zdarzenia dotyczącego bezpieczeństwa jest podpisany przy użyciu klucza publicznego uzyskanego w poprzednim kroku.
   • Żądanie aud tokena jest jednym z identyfikatorów klienta aplikacji.
   • Żądanie iss tokena jest zgodne z identyfikatorem wydawcy uzyskanym z dokumentu wykrywania RISC. Pamiętaj, że nie musisz weryfikować ważności tokena (exp), ponieważ tokeny zdarzeń zabezpieczeń odpowiadają treściom historycznym.

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ł dekodowany, zwracaj stan HTTP 202. Obsługuj zdarzenie związane z bezpieczeństwem oznaczone przez token.

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

Po zdekodowaniu token zabezpieczeń bezpieczeństwa 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"
    }
  }
}

Roszczenia iss i aud wskazują wydawcę tokena (Google) i docelowego odbiorcę tokena (Twoją usługę). Te twierdzenia zostały zweryfikowane w poprzednim kroku.

Roszczenie jti to ciąg znaków, który identyfikuje jedno zdarzenie związane z bezpieczeństwem i jest unikalny dla strumienia. Możesz go użyć, aby śledzić otrzymane zdarzenia związane z bezpieczeństwem.

Deklaracja events zawiera informacje o zdarzeniu związanym z bezpieczeństwem, które jest powiązane z tokenem. To roszczenie jest mapowane z identyfikatora typu zdarzenia do deklaracji subject, która wskazuje użytkownika, którego dotyczy to zdarzenie, oraz na wszelkie dodatkowe szczegóły zdarzenia, które mogą być dostępne.

Roszczenie subject identyfikuje konkretnego użytkownika za pomocą unikalnego identyfikatora konta Google użytkownika (sub). Jest to ten sam identyfikator konta Google (sub), który znajduje się w tokenach tokena JWT w nowszej bibliotece Zaloguj się przez Google (JavaScript, HTML), starszej bibliotece Logowania przez Google lub OpenID Connect. Gdy element subject_type roszczenia to id_token_claims, może też zawierać pole email z adresem e-mail użytkownika.

Wykorzystaj informacje zawarte w roszczeniu events, aby podjąć odpowiednie działanie dla typu zdarzenia na koncie określonego użytkownika.

Identyfikatory tokenów OAuth

W przypadku zdarzeń OAuth poszczególnych tokenów typ identyfikatora token tokenu zawiera te pola:

• token_type: obsługiwana jest tylko opcja refresh_token.

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

• token: patrz tabela poniżej.

W przypadku integracji z tymi zdarzeniami zaleca się indeksowanie tokenów na podstawie tych wartości. Pozwoli to uzyskać 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 zdarzenia

Ochrona wszystkich kont spróbuje ponownie przesłać zdarzenia, które według niego nie zostały dostarczone. Z tego powodu możesz czasami otrzymać to samo zdarzenie. Jeśli może to spowodować powtarzane działania, które są uciążliwe dla użytkowników, możesz usunąć zdarzenie za pomocą roszczenia jti (jest to unikalny identyfikator zdarzenia). Dostępne są narzędzia zewnętrzne, takie jak Google Cloud Dataflow, które mogą ułatwić Ci usunięcie przepływu danych.

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

Zarejestruj odbiornik

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

Będziesz otrzymywać zdarzenia zabezpieczeń tylko dla użytkowników aplikacji, dlatego musisz skonfigurować ekran zgody OAuth w projekcie GCP jako warunek wstępny opisany poniżej.

1. Generowanie tokena autoryzacji

Aby wygenerować token autoryzacji dla interfejsu RISC API, utwórz token JWT z tymi roszczeniami:

{
  "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 token JWT przy użyciu klucza prywatnego konta usługi, który znajdziesz w pliku JSON pobranym 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 API RISC przez godzinę. Po wygaśnięciu tokena wygeneruj nowy, aby kontynuować wykonywanie wywołań interfejsu RISC API.

2. Wywoływanie interfejsu konfiguracji strumienia RISC

Gdy masz już token autoryzacyjny, możesz użyć interfejsu RISC API, aby skonfigurować strumień zdarzeń związanych z bezpieczeństwem projektu, w tym zarejestrować punkt końcowy odbiornika.

Aby to zrobić, wyślij żądanie HTTPS POST do https://risc.googleapis.com/v1beta/stream:update, podając punkt końcowy odbiornika i rodzaje zdarzeń związanych z bezpieczeństwem, 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 HTTP 200, strumień zdarzeń został skonfigurowany, a punkt końcowy odbiorcy powinien zacząć otrzymywać tokeny zdarzeń zabezpieczeń. W następnej sekcji dowiesz się, jak przetestować konfigurację strumienia i punktu końcowego, aby sprawdzić, czy wszystko działa prawidłowo.

Pobieranie i aktualizowanie bieżącej konfiguracji strumienia

Jeśli w przyszłości zechcesz zmienić konfigurację strumienia, możesz to zrobić, autoryzując żądanie GET do usługi https://risc.googleapis.com/v1beta/stream, aby pobrać aktualną konfigurację strumienia. W tym celu musisz zmodyfikować treść odpowiedzi, a potem POST zmodyfikowaną konfigurację z powrotem do https://risc.googleapis.com/v1beta/stream:update w sposób opisany powyżej.

Zatrzymywanie i wznawianie strumienia zdarzeń

Jeśli chcesz zatrzymać strumień zdarzeń od Google, wyślij żądanie autoryzacji POST do https://risc.googleapis.com/v1beta/stream/status:update za pomocą { "status": "disabled" } w treści żądania. Gdy strumień jest wyłączony, Google nie wysyła zdarzeń do punktu końcowego i nie buforuje zdarzeń bezpieczeństwa, gdy występują. Aby ponownie włączyć strumień zdarzeń, wyślij żądanie { "status": "enabled" } do tego samego punktu końcowego.

3. Opcjonalnie: testowanie konfiguracji strumienia

Możesz sprawdzić, czy konfiguracja strumienia i punktu końcowego odbiornika działają prawidłowo, wysyłając token weryfikacyjny przez strumień zdarzeń. Ten token może zawierać unikalny ciąg znaków, którego możesz użyć do sprawdzenia, czy token został otrzymany w punkcie końcowym. Aby użyć tego przepływu, podczas rejestrowania odbiornika zasubskrybuj https://schemas.openid.net/secevent/risc/event-type/verification typ zdarzenia.

Aby poprosić o token weryfikacyjny, wyślij do żądania https://risc.googleapis.com/v1beta/stream:verify autoryzowane żądanie HTTPS POST. 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 zarejestrowanego punktu końcowego. Jeśli na przykład Twój punkt końcowy obsługuje tokeny weryfikacyjne, po prostu je zaloguj, możesz przejrzeć dzienniki w celu sprawdzenia, czy token został odebrany.

Dokumentacja kodu błędu

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

Zakresy tokenów dostępu

Jeśli zdecydujesz się na używanie tokenów dostępu do uwierzytelniania w interfejsie RISC API, aplikacja musi uzyskać te zakresy:

Potrzebujesz pomocy?

Najpierw zapoznaj się z sekcją Informacje o kodach błędów. Jeśli nadal masz pytania, zadaj je na stronie Stack Overflow za pomocą tagu #SecEvents.