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

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Jeśli użytkownicy w Twojej aplikacji mogą logować się na swoje konta Google, możesz zwiększyć bezpieczeństwo tych udostępnianych kont, nasłuchując powiadomień o zdarzeniach związanych z bezpieczeństwem i odpowiadając na nie.

Powiadomienia informują o poważnych zmianach na kontach Google użytkowników, co często wpływa na bezpieczeństwo ich aplikacji. Na przykład jeśli konto Google użytkownika zostanie przejęte, jego konto może zostać przejęte za pomocą funkcji odzyskiwania konta e-mail lub logowania jednokrotnego.

Aby ograniczyć ryzyko związane z takimi zdarzeniami, Google wysyła obiekty usługi nazywane tokenami zabezpieczeń. Zawierają one bardzo mało informacji – tylko typ zdarzenia związanego z bezpieczeństwem i czas wystąpienia zdarzenia oraz identyfikator użytkownika, u którego wystąpił problem. Możesz ich jednak użyć do podjęcia odpowiednich działań. Na przykład jeśli do konta Google zostało przejęte konto użytkownika, możesz tymczasowo wyłączyć funkcję Zaloguj się przez Google dla tego użytkownika i zapobiegać wysyłaniu na jego adres e-mail odzyskiwania.

Ochrona wszystkich kont działa na podstawie standardu RISC opracowanego przez organizację OpenID Foundation.

Opis

Aby korzystać z ochrony obejmującej wiele 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 zdarzeń, do którego Google będzie wysyłać tokeny zdarzeń zabezpieczeń. Ten punkt końcowy odpowiada za weryfikację tokenów, które otrzymuje, 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 przyznali Twojej usłudze dostęp do danych jej profili lub adresów e-mail. Aby uzyskać to uprawnienie, poproś o zakres profile lub email. Nowsze zakresy domyślnie korzystają z nowszych pakietów Sign In with Google lub starszych logowań Google, ale jeśli nie używasz ustawień domyślnych lub jeśli uzyskujesz dostęp bezpośrednio do punktu końcowego OpenID Google, sprawdź, czy żądasz co najmniej jednego z tych zakresów.

Konfigurowanie projektu w API Console

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

Aby utworzyć konto usługi:

  1. Otwórz API Console Credentials page. Gdy pojawi się taka prośba, 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ą edytora.

  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. Zachowaj ten plik w bezpiecznym miejscu, ale będzie też dostępny dla punktu końcowego odbiornika zdarzeń.

Gdy jesteś na stronie danych logowania w projekcie, zwracaj uwagę na identyfikatory klienta, których używasz do logowania się przez Google lub logowania starszego typu. Zwykle dla każdej obsługiwanej platformy masz identyfikator klienta. Te identyfikatory klienta będą potrzebne do weryfikacji tokenów zdarzeń zgodnie z opisem w następnej sekcji.

Aby włączyć interfejs RISC API:

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

  2. Zapoznaj się z warunkami RISC i upewnij się, że rozumiesz je.

    Jeśli włączasz interfejs API dla projektu należącego do organizacji, upewnij się, że masz uprawnienia do powiązania organizacji z warunkami RISC.

  3. Kliknij Włącz tylko wtedy, gdy zgadzasz się 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ć kryptograficznie ciągi znaków zwane tokenami zabezpieczeń i punkt końcowy. 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 zabezpieczeń, który otrzymasz w punkcie końcowym, najpierw zweryfikuj i zdekoduj token, a następnie zajmij się zdarzeniem zabezpieczeń odpowiednim dla Twojej usługi. Zweryfikuj token zdarzenia przed dezaktywacją, by zapobiec złośliwym atakom hakerów. Tematy w tych sekcjach:

1. Zdekoduj i zweryfikuj token zdarzenia zabezpieczeń

Tokeny zdarzeń zabezpieczeń to specjalny rodzaj tokena JWT, dlatego możesz go dezaktywować i zweryfikować za pomocą dowolnej biblioteki JWT, np. wymienionej na stronie jwt.io. Niezależnie od używanej biblioteki kod weryfikacyjny tokena musi mieć postać:

  1. Pobierz identyfikator wydawcy ochrony dla wielu kont (issuer) i identyfikator URI certyfikatu podpisywania klucza (jwks_uri) z dokumentu konfiguracji RISC Google, który znajdziesz pod adresem https://accounts.google.com/.well-known/risc-configuration.
  2. Użyj wybranej biblioteki tokena JWT, aby uzyskać identyfikator klucza podpisywania z nagłówka tokena zdarzenia zabezpieczeń.
  3. Z dokumentu certyfikatu klucza podpisywania Google uzyskaj klucz publiczny z identyfikatorem klucza otrzymanym 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 zwracać błąd HTTP 400.
  4. Korzystając z wybranej biblioteki JWT, sprawdź:
    • Token zdarzenia dotyczącego zabezpieczeń został podpisany przy użyciu klucza publicznego otrzymanego w poprzednim kroku.
    • Żądanie aud do tokena jest jedną z Twoich aplikacji. Identyfikatory klientów.
    • Żądanie iss tokena odpowiada identyfikatorowi wydawcy uzyskanemu w dokumencie wykrywania RISC. Pamiętaj, że nie musisz weryfikować ważności tokena (exp), ponieważ tokeny zdarzeń związanych z bezpieczeństwem przedstawiają zdarzenia historyczne i dlatego nie wygasają.

Przykład:

Java

Używanie elementów java-jwt i jwks-rsa-java:

public DecodedJWT validateSecurityEventToken(String token) {
    DecodedJWT jwt = null;
    try {
        // In a real implementation, get these values from
        // https://accounts.google.com/.well-known/risc-configuration
        String issuer = "accounts.google.com";
        String jwksUri = "https://www.googleapis.com/oauth2/v3/certs";

        // Get the ID of the key used to sign the token.
        DecodedJWT unverifiedJwt = JWT.decode(token);
        String keyId = unverifiedJwt.getKeyId();

        // Get the public key from Google.
        JwkProvider googleCerts = new UrlJwkProvider(new URL(jwksUri), null, null);
        PublicKey publicKey = googleCerts.get(keyId).getPublicKey();

        // Verify and decode the token.
        Algorithm rsa = Algorithm.RSA256((RSAPublicKey) publicKey, null);
        JWTVerifier verifier = JWT.require(rsa)
                .withIssuer(issuer)
                // Get your apps' client IDs from the API console:
                // https://console.developers.google.com/apis/credentials?project=_
                .withAudience("123456789-abcedfgh.apps.googleusercontent.com",
                              "123456789-ijklmnop.apps.googleusercontent.com",
                              "123456789-qrstuvwx.apps.googleusercontent.com")
                .acceptLeeway(Long.MAX_VALUE)  // Don't check for expiration.
                .build();
        jwt = verifier.verify(token);
    } catch (JwkException e) {
        // Key not found. Return HTTP 400.
    } catch (InvalidClaimException e) {

    } catch (JWTDecodeException exception) {
        // Malformed token. Return HTTP 400.
    } catch (MalformedURLException e) {
        // Invalid JWKS URI.
    }
    return jwt;
}

Python

import json
import jwt       # pip install pyjwt
import requests  # pip install requests

def validate_security_token(token, client_ids):
    # Get Google's RISC configuration.
    risc_config_uri = 'https://accounts.google.com/.well-known/risc-configuration'
    risc_config = requests.get(risc_config_uri).json()

    # Get the public key used to sign the token.
    google_certs = requests.get(risc_config['jwks_uri']).json()
    jwt_header = jwt.get_unverified_header(token)
    key_id = jwt_header['kid']
    public_key = None
    for key in google_certs['keys']:
        if key['kid'] == key_id:
            public_key = jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps(key))
    if not public_key:
        raise Exception('Public key certificate not found.')
        # In this situation, return HTTP 400

    # Decode the token, validating its signature, audience, and issuer.
    try:
        token_data = jwt.decode(token, public_key, algorithms='RS256',
                                options={'verify_exp': False},
                                audience=client_ids, issuer=risc_config['issuer'])
    except:
        raise
        # Validation failed. Return HTTP 400.
    return token_data

# Get your apps' client IDs from the API console:
# https://console.developers.google.com/apis/credentials?project=_
client_ids = ['123456789-abcedfgh.apps.googleusercontent.com',
              '123456789-ijklmnop.apps.googleusercontent.com',
              '123456789-qrstuvwx.apps.googleusercontent.com']
token_data = validate_security_token(token, client_ids)

Jeśli token jest prawidłowy i zdekodowany, ustaw stan HTTP 202. Następnie zarządzaj zdarzeniem zabezpieczeń wskazanym przez token.

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

Po zdekodowaniu token zdarzenia zabezpieczeń 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ą wystawcę tokena (Google) oraz adresata, do którego należy token (Twoja usługa). Te roszczenia zostały zweryfikowane w poprzednim kroku.

Roszczenie jti to ciąg znaków identyfikujący pojedyncze zdarzenie dotyczące bezpieczeństwa, które jest unikalne dla strumienia. Możesz go użyć, aby śledzić, jakie zdarzenia związane z bezpieczeństwem otrzymały.

Deklaracja events zawiera informacje o zdarzeniu zabezpieczeń reprezentowanym przez token. To roszczenie odnosi się do mapowania typu identyfikatora zdarzenia na deklarację subject, która określa użytkownika, którego dotyczy to zdarzenie, oraz wszelkie dodatkowe informacje o dostępnym zdarzeniu.

Żądanie subject identyfikuje konkretnego użytkownika za pomocą unikalnego identyfikatora konta Google (sub). Ten identyfikator konta Google to ten sam identyfikator (sub) zawarty w tokenach identyfikatora JWT udostępnionych przez nowszą bibliotekę Zaloguj się przez Google (JavaScript, HTML), starszą bibliotekę Logowanie przez Google lub OpenID Connect. Jeśli subject_type roszczenia obejmuje id_token_claims, może też zawierać pole email z adresem e-mail użytkownika.

Skorzystaj z informacji w deklaracji events, aby podjąć odpowiednie działanie dla określonego typu zdarzenia na określonym koncie użytkownika.

Identyfikatory tokenów OAuth

W przypadku zdarzeń OAuth dotyczących poszczególnych tokenów typ identyfikatora token token 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: zapoznaj się z tabelą poniżej.

token_identifier_alg token
prefix Pierwsze 16 znaków tokena.
hash_base64_sha512_sha512 Podwójny hasz tokena za pomocą algorytmu SHA-512.

W przypadku integracji z tymi zdarzeniami sugerujemy indeksowanie tokenów na podstawie podanych 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:

Typ zdarzenia Atrybuty Jak odpowiadać
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked Wymagane: zabezpiecz ponownie konto użytkownika, zamykając obecnie otwarte sesje.
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

Wymagane: jeśli token dotyczy logowania przez Google, zakończ bieżące sesje. Możesz też zaproponować użytkownikowi skonfigurowanie alternatywnej metody logowania.

Sugerowane: jeśli token zapewnia dostęp do innych interfejsów API Google, usuń każdy z zapisanych tokenów OAuth użytkownika.

https://schemas.openid.net/secevent/oauth/event-type/token-revoked Informacje o identyfikatorach tokenów znajdziesz w sekcji Identyfikatory tokenów OAuth

Wymagane: jeśli przechowujesz odpowiedni token odświeżania, usuń go i poproś użytkownika o ponowne wyrażenie zgody przy następnym tokenie dostępu.

https://schemas.openid.net/secevent/risc/event-type/account-disabled reason=hijacking,
reason=bulk-account

Wymagane: jeśli przyczyna wyłączenia konta to hijacking, zabezpiecz ponownie konto użytkownika, zamykając obecnie otwarte sesje.

Sugerowane: jeśli przyczyna wyłączenia konta to bulk-account, przeanalizuj aktywność użytkownika w usłudze i określ dalsze działania.

Sugerowane: jeśli nie podano powodu, wyłącz logowanie Google dla użytkownika i wyłącz odzyskiwanie konta przy użyciu adresu e-mail powiązanego z kontem Google użytkownika (zwykle nie musi to być konto Gmail). Zaoferuj użytkownikowi alternatywną metodę logowania.

https://schemas.openid.net/secevent/risc/event-type/account-enabled Sugerowane: włącz ponownie logowanie Google dla użytkownika i ponownie włącz konto za pomocą adresu e-mail konta Google użytkownika.
https://schemas.openid.net/secevent/risc/event-type/account-purged Sugerowane: usuń konto użytkownika lub udostępnij mu alternatywną metodę logowania.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Sugerowane: obserwuj podejrzaną aktywność w usłudze i podejmuj odpowiednie działania.
https://schemas.openid.net/secevent/risc/event-type/verification stan=state Sugerowane: zapisz otrzymany token testowy.

Zduplikowane i pominięte zdarzenia

Funkcja ochrony wszystkich kont spróbuje ponownie przesłać zdarzenia, które ich zdaniem nie zostały dostarczone. Dlatego czasami możesz otrzymać to samo zdarzenie kilka razy. Jeśli może to powodować powtarzające się działania niewygodne dla użytkowników, spróbuj usunąć twierdzenie jti (jest to unikalny identyfikator zdarzenia). Dostępne są zewnętrzne narzędzia, takie jak Google Cloud Dataflow, które mogą ułatwić Ci usunięcie zbędnego przepływu danych.

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

Rejestrowanie odbiornika

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

Zdarzenia dotyczące bezpieczeństwa będą otrzymywać tylko dla użytkowników aplikacji, więc musisz skonfigurować ekran zgody OAuth w swoim projekcie GCP, wykonując czynności opisane 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 za pomocą klucza prywatnego konta usługi, który znajdziesz w pliku JSON pobranym podczas tworzenia klucza konta usługi.

Przykład:

Java

Używanie biblioteki java-jwt i Google's auth:

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

Ten token autoryzacji może służyć do wykonywania wywołań interfejsu API RISC na godzinę. Po wygaśnięciu tokena wygeneruj nowy, aby kontynuować wywołania interfejsu RISC API.

2. Wywołaj interfejs API konfiguracji strumienia RISC

Masz już token autoryzacji, więc możesz użyć interfejsu RISC API do skonfigurowania strumienia zdarzeń związanych z zabezpieczeniami projektu, w tym zarejestrowania punktu końcowego odbiornika.

Aby to zrobić, wyślij żądanie HTTPS POST do usługi https://risc.googleapis.com/v1beta/stream:update z określeniem punktu końcowego odbiornika i typów zdarzeń zabezpieczeń, 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
  ]
}

Przykład:

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

Jeśli żądanie zwróci HTTP 200, strumień zdarzeń został skonfigurowany, a punkt końcowy odbiornika powinien zacząć otrzymywać tokeny zabezpieczeń. W następnej sekcji opisujemy, jak możesz przetestować konfigurację strumienia i punkt końcowy, by 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 strony https://risc.googleapis.com/v1beta/stream, aby pobrać bieżącą konfigurację strumienia, modyfikując treść odpowiedzi, a następnie przesyłając zmodyfikowaną konfigurację z powrotem do https://risc.googleapis.com/v1beta/stream:update w sposób opisany powyżej.

Zatrzymaj i wznów strumień wydarzenia

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

3. Opcjonalnie: przetestuj konfigurację 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ł odebrany w punkcie końcowym.

Aby wysłać prośbę o token weryfikacyjny, wyślij żądanie POST do protokołu HTTPS do: https://risc.googleapis.com/v1beta/stream:verify. W treści żądania podaj ciąg identyfikujący:

{
  "state": "ANYTHING"
}

Przykład:

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

Jeśli żądanie się powiedzie, token weryfikacyjny zostanie wysłany do zarejestrowanego punktu końcowego. Jeśli na przykład punkty końcowe obsługują tokeny weryfikacyjne, wystarczy je zarejestrować, aby można było sprawdzić logi, czy token został odebrany.

Dokumentacja kodu błędu

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

Kod błędu Komunikat o błędzie Sugerowane działania
400 Konfiguracja strumienia musi zawierać pole $fieldname. Twoje żądanie skierowane do punktu końcowego https://risc.googleapis.com/v1beta/stream:update jest nieprawidłowe lub nie można go przeanalizować. Dołącz do prośby pole $fieldname.
401 Brak autoryzacji. Autoryzacja nie powiodła się. Upewnij się, że do żądania załączono token autoryzacji oraz że jest on ważny i nie stracił ważności.
403 Punkt końcowy wyświetlania musi być adresem URL HTTPS. Punkt końcowy dostarczania (tzn. punkt końcowy, do którego powinny być dostarczane zdarzenia RISC) musi być HTTPS. Nie wysyłamy zdarzeń RISC na adresy URL HTTP.
403 Istniejąca konfiguracja strumienia nie ma zgodnej ze specyfikacją metody dostarczania RISC. Twój projekt Google Cloud musi mieć konfigurację RISC. Jeśli korzystasz z Firebase i masz włączone logowanie Google, Firebase będzie zarządzać RISC dla Twojego projektu. Nie będzie można utworzyć konfiguracji niestandardowej. Jeśli nie korzystasz z logowania przez Google w projekcie Firebase, wyłącz je, a potem spróbuj ponownie przeprowadzić aktualizację po godzinie.
403 Nie znaleziono projektu. Sprawdź, czy używasz właściwego konta usługi we właściwym projekcie. Być może używasz konta usługi powiązanego z usuniętym projektem. Dowiedz się, jak wyświetlić wszystkie konta usługi powiązane z projektem.
403 Konto usługi musi mieć uprawnienia edytującego w Twoim projekcie. Otwórz konsolę Google Cloud Platform w swoim projekcie i przyznaj kontu usługi, które wprowadza uprawnienia do edytora lub właściciela połączeń, zgodnie z tymi instrukcjami.
403 Interfejsy API zarządzania strumieniem powinny być wywoływane tylko przez konto usługi. Dowiedz się więcej o wywoływaniu interfejsów API Google za pomocą konta usługi.
403 Punkt końcowy dostarczania nie należy do żadnej z domen projektu. Każdy projekt ma zestaw autoryzowanych domen. Jeśli punkt końcowy (tzn. punkt końcowy, do którego powinny być dostarczane zdarzenia RISC) nie jest hostowany w jednym z tych punktów, wymagamy dodania do tego domeny domeny punktu końcowego.
403 Aby korzystać z tego interfejsu API, w Twoim projekcie musi być skonfigurowany co najmniej jeden klient OAuth. RISC działa tylko wtedy, gdy utworzysz aplikację, która obsługuje Logowanie przez Google. To połączenie wymaga klienta OAuth. Jeśli w Twoim projekcie nie ma klientów OAuth, RISC prawdopodobnie nie będzie dla Ciebie przydatny. Dowiedz się więcej o zastosowaniu protokołu OAuth do interfejsów API w Google.
403

Nieobsługiwany stan.

Nieprawidłowy stan.

Obecnie obsługujemy tylko stany strumienia „enabled” i „disabled”.
404

Projekt nie ma konfiguracji RISC.

Projekt nie ma istniejącej konfiguracji RISC, nie można zaktualizować stanu.

Aby utworzyć nową konfigurację strumienia, wywołaj punkt końcowy https://risc.googleapis.com/v1beta/stream:update.
4XX/5XX Nie można zaktualizować stanu. Aby uzyskać więcej informacji, sprawdź szczegółowy komunikat o błędzie.

Zakresy tokenów dostępu

Jeśli zdecydujesz się na używanie tokenów dostępu do uwierzytelniania w interfejsie RISC API, poproś o to te zakresy:

Punkt końcowy Zakres
https://risc.googleapis.com/v1beta/stream/status https://www.googleapis.com/auth/risc.status.readonly LUB 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 LUB 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

Potrzebujesz pomocy?

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