Chroń konta użytkowników za pomocą funkcji Cross-Account Protection

Jeśli Twoja aplikacja umożliwia użytkownikom logowanie się na ich konta przy użyciu Google, możesz zwiększyć bezpieczeństwo kont tych współużytkowników, słuchając i odpowiadając na powiadomienia o zdarzeniach bezpieczeństwa udostępniane przez usługę Cross-Account Protection.

Powiadomienia te informują o poważnych zmianach na kontach Google Twoich użytkowników, które często mogą mieć 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 potencjalnie doprowadzić do włamania do konta użytkownika w Twojej aplikacji poprzez odzyskiwanie konta e-mail lub użycie jednokrotnego logowania.

Aby pomóc Ci ograniczyć potencjalne ryzyko związane z takimi zdarzeniami, Google wysyła obiekty usługi zwane tokenami zdarzeń bezpieczeństwa. Te tokeny ujawniają bardzo mało informacji — tylko typ zdarzenia bezpieczeństwa i czas jego wystąpienia oraz identyfikator użytkownika, którego dotyczy problem — ale można ich użyć do podjęcia odpowiednich działań w odpowiedzi. Na przykład, jeśli ktoś włamał się na konto Google użytkownika, możesz tymczasowo wyłączyć logowanie przez Google dla tego użytkownika i uniemożliwić wysyłanie e-maili służących do odzyskiwania konta na jego adres Gmail.

Cross-Account Protection opiera się na standardzie RISC , opracowanym przez OpenID Foundation.

Przegląd

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

  1. Skonfiguruj swój projekt w API Console.

  2. Utwórz punkt końcowy odbiornika zdarzeń, do którego Google będzie wysyłać tokeny zdarzeń zabezpieczających. Ten punkt końcowy jest odpowiedzialny za weryfikację otrzymanych tokenów, a następnie reagowanie na zdarzenia bezpieczeństwa w wybrany przez Ciebie sposób.

  3. Zarejestruj swój punkt końcowy w Google, aby zacząć otrzymywać tokeny zdarzeń bezpieczeństwa.

Warunek wstępny

Tokeny zdarzeń zabezpieczających otrzymujesz tylko dla użytkowników Google, którzy przyznali Twojej usłudze uprawnienia dostępu do swoich informacji profilowych lub adresów e-mail. Uprawnienie to otrzymujesz, prosząc o profile lub zakresy email . Nowsze pakiety Sign In With Google lub starsze pakiety SDK logowania Google domyślnie żądają tych zakresów, ale jeśli nie używasz ustawień domyślnych lub jeśli uzyskujesz bezpośredni dostęp do punktu końcowego OpenID Connect firmy Google, upewnij się, że żądasz co najmniej jednego z tych zakresów zakresy.

Skonfiguruj projekt w API Console

Przed rozpoczęciem otrzymywania tokenów zdarzeń zabezpieczeń należy utworzyć konto usługi i włączyć interfejs API RISC w projekcieAPI Console . Musisz użyć tego samego projektuAPI Console , którego używasz do uzyskiwania dostępu do usług Google, takich jak Google Signin, w swojej aplikacji.

Aby utworzyć konto usługi:

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

  2. Kliknij Utwórz poświadczenia > Konto usługi .

  3. Utwórz nowe konto usługi z rolą Edytujący.

  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 poświadczenia Twojego konta usługi. Przechowuj ten plik w bezpiecznym miejscu, ale także dostępnym dla punktu końcowego odbiornika zdarzeń.

Gdy jesteś na stronie Poświadczenia projektu, zanotuj też identyfikatory klienta, których używasz do logowania się przez Google lub logowania przez Google (starsza wersja). Zazwyczaj masz identyfikator klienta dla każdej obsługiwanej platformy. Te identyfikatory klientów będą potrzebne do weryfikacji tokenów zdarzeń bezpieczeństwa, zgodnie z opisem w następnej sekcji.

Aby włączyć interfejs API RISC:

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

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

    Jeśli włączasz interfejs API dla projektu należącego do organizacji, upewnij się, że jesteś upoważniony do związania swojej organizacji Warunkami RISC.

  3. Kliknij opcję Włącz tylko, jeśli wyrażasz zgodę na Warunki RISC.

Utwórz punkt końcowy odbiornika zdarzeń

Aby otrzymywać powiadomienia o zdarzeniach bezpieczeństwa od Google, tworzysz punkt końcowy HTTPS, który obsługuje żądania HTTPS POST. Po zarejestrowaniu tego punktu końcowego (patrz poniżej) Google zacznie przesyłać do punktu końcowego podpisane kryptograficznie ciągi zwane tokenami zdarzeń bezpieczeństwa. Tokeny zdarzeń zabezpieczeń to podpisane tokeny JWT, które zawierają informacje o pojedynczym zdarzeniu związanym z bezpieczeństwem.

W przypadku każdego tokenu zdarzenia bezpieczeństwa otrzymanego w punkcie końcowym najpierw sprawdź poprawność i zdekoduj token, a następnie obsługuj zdarzenie bezpieczeństwa odpowiednio do Twojej usługi. Niezbędne jest zweryfikowanie tokenu zdarzenia przed dekodowaniem, aby zapobiec złośliwym atakom ze strony złych podmiotów. Poniższe sekcje opisują te zadania:

1. Odszyfruj i zweryfikuj token zdarzenia bezpieczeństwa

Ponieważ tokeny zdarzeń bezpieczeństwa są specyficznym rodzajem tokenów JWT, możesz użyć dowolnej biblioteki JWT, takiej jak wymieniona na jwt.io , do ich dekodowania i sprawdzania poprawności. Niezależnie od używanej biblioteki, kod weryfikacyjny tokena musi wykonać następujące czynności:

  1. Uzyskaj identyfikator wystawcy ochrony wielu kont ( issuer ) i identyfikator URI certyfikatu klucza podpisywania ( jwks_uri ) z dokumentu konfiguracyjnego RISC firmy Google, który można znaleźć pod https://accounts.google.com/.well-known/risc-configuration .
  2. Korzystając z wybranej biblioteki JWT, pobierz identyfikator klucza podpisywania z nagłówka tokenu zdarzenia bezpieczeństwa.
  3. Z dokumentu certyfikatu klucza podpisywania Google pobierz klucz publiczny z identyfikatorem klucza otrzymanym w poprzednim kroku. Jeśli dokument nie zawiera klucza o identyfikatorze, którego szukasz, prawdopodobnie token zdarzenia bezpieczeństwa jest nieprawidłowy, a punkt końcowy powinien zwrócić błąd HTTP 400.
  4. Korzystając z wybranej biblioteki JWT, sprawdź następujące elementy:
    • Token zdarzenia bezpieczeństwa jest podpisany przy użyciu klucza publicznego, który otrzymałeś w poprzednim kroku.
    • Roszczenie aud tokena jest jednym z identyfikatorów klienta Twoich aplikacji.
    • Roszczenie iss tokena jest zgodne z identyfikatorem wydawcy otrzymanym z dokumentu wykrywania RISC. Pamiętaj, że nie musisz weryfikować wygaśnięcia tokenu ( exp ), ponieważ tokeny zdarzeń bezpieczeństwa reprezentują zdarzenia historyczne i jako takie nie wygasają.

Na przykład:

Jawa

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

Pyton

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żeli token jest ważny i został pomyślnie zdekodowany, zwróć status HTTP 202. Następnie obsłuż zdarzenie bezpieczeństwa wskazane przez token.

2. Obsługuj zdarzenia związane z bezpieczeństwem

Po zdekodowaniu token zdarzenia bezpieczeństwa wygląda jak w następującym przykładzie:

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

Oświadczenia iss i aud wskazują wystawcę tokena (Google) oraz zamierzonego odbiorcę tokenu (Twoja usługa). Zweryfikowałeś te roszczenia w poprzednim kroku.

Roszczenie jti to łańcuch, który identyfikuje pojedyncze zdarzenie bezpieczeństwa i jest unikalny dla strumienia. Możesz użyć tego identyfikatora do śledzenia otrzymanych zdarzeń bezpieczeństwa.

Oświadczenie events zawiera informacje o zdarzeniu bezpieczeństwa, które reprezentuje token. To oświadczenie jest mapowaniem z identyfikatora typu zdarzenia na oświadczenie subject , które określa użytkownika, którego dotyczy to zdarzenie, oraz wszelkie dodatkowe szczegóły dotyczące zdarzenia, które mogą być dostępne.

Roszczenie subject identyfikuje konkretnego użytkownika za pomocą jego unikalnego identyfikatora konta Google ( sub ). Ten identyfikator konta Google jest tym samym identyfikatorem ( sub ) co tokeny identyfikatora JWT wydane przez nowszą bibliotekę Sign In With Google ( Javascript , HTML ), starszą bibliotekę Google Signin lub OpenID Connect . Gdy subject_type roszczenia jest id_token_claims , może również zawierać pole email -mail z adresem e-mail użytkownika.

Użyj informacji w oświadczeniu o events , aby podjąć odpowiednie działania dla typu zdarzenia na określonym koncie użytkownika.

Obsługiwane typy zdarzeń

Ochrona Cross-Account obsługuje następujące typy zdarzeń związanych z bezpieczeństwem:

Typ wydarzenia Atrybuty Jak odpowiedzieć
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked Wymagane : ponownie zabezpiecz konto użytkownika, kończąc jego aktualnie otwarte sesje.
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

Wymagane : jeśli token służy do logowania przez Google, zakończ ich aktualnie otwarte sesje. Ponadto możesz zasugerować użytkownikowi skonfigurowanie alternatywnej metody logowania.

Sugerowane : jeśli token służy do dostępu do innych interfejsów API Google, usuń wszystkie zapisane tokeny OAuth użytkownika.

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

Wymagane : jeśli przyczyną wyłączenia konta było hijacking konta , ponownie zabezpiecz konto użytkownika, kończąc jego aktualnie otwarte sesje.

Sugerowane : jeśli przyczyną wyłączenia konta było konto bulk-account , przeanalizuj aktywność użytkownika w Twojej usłudze i określ odpowiednie działania następcze.

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

https://schemas.openid.net/secevent/risc/event-type/account-enabled Sugerowane : ponownie włącz logowanie przez Google dla użytkownika i ponownie włącz odzyskiwanie konta przy użyciu 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 : zwróć uwagę na podejrzaną aktywność w swojej usłudze i podejmij odpowiednie działania.
https://schemas.openid.net/secevent/risc/event-type/verification stan= state Sugerowane : Rejestruj, że otrzymano token testowy.

Zduplikowane i nieodebrane wydarzenia

Ochrona wielu kont podejmie próbę ponownego dostarczenia zdarzeń, które według niej nie zostały dostarczone. Dlatego czasami możesz wielokrotnie otrzymywać to samo wydarzenie. Jeśli może to spowodować powtarzające się działania, które są niewygodne dla użytkowników, rozważ użycie roszczenia jti (który jest unikalnym identyfikatorem zdarzenia) w celu usunięcia zduplikowanych zdarzeń. Istnieją zewnętrzne narzędzia, takie jak Google Cloud Dataflow , które mogą pomóc w wykonaniu przepływu danych deduplikacji.

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

Zarejestruj odbiornik

Aby rozpocząć odbieranie zdarzeń związanych z bezpieczeństwem, zarejestruj punkt końcowy odbiornika za pomocą interfejsu API RISC. Wywołaniom interfejsu API RISC musi towarzyszyć token autoryzacji.

Będziesz otrzymywać zdarzenia dotyczące bezpieczeństwa tylko dla użytkowników Twojej aplikacji, więc musisz mieć skonfigurowany ekran akceptacji OAuth w swoim projekcie GCP jako warunek wstępny wykonania opisanych poniżej kroków.

1. Wygeneruj token autoryzacyjny

Aby wygenerować token autoryzacji dla interfejsu API RISC, utwórz token JWT z następującymi oświadczeniami:

{
  "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 można znaleźć w pliku JSON pobranym podczas tworzenia klucza konta usługi.

Na przykład:

Jawa

Korzystanie z java-jwt i biblioteki uwierzytelniania Google :

public static String makeBearerToken() {
    String token = null;
    try {
        // Get signing key and client email address.
        FileInputStream is = new FileInputStream("your-service-account-credentials.json");
        ServiceAccountCredentials credentials =
               (ServiceAccountCredentials) GoogleCredentials.fromStream(is);
        PrivateKey privateKey = credentials.getPrivateKey();
        String keyId = credentials.getPrivateKeyId();
        String clientEmail = credentials.getClientEmail();

        // Token must expire in exactly one hour.
        Date issuedAt = new Date();
        Date expiresAt = new Date(issuedAt.getTime() + 3600000);

        // Create signed token.
        Algorithm rsaKey = Algorithm.RSA256(null, (RSAPrivateKey) privateKey);
        token = JWT.create()
                .withIssuer(clientEmail)
                .withSubject(clientEmail)
                .withAudience("https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService")
                .withIssuedAt(issuedAt)
                .withExpiresAt(expiresAt)
                .withKeyId(keyId)
                .sign(rsaKey);
    } catch (ClassCastException e) {
        // Credentials file doesn't contain a service account key.
    } catch (IOException e) {
        // Credentials file couldn't be loaded.
    }
    return token;
}

Pyton

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 przez godzinę. Gdy token wygaśnie, wygeneruj nowy, aby kontynuować wykonywanie wywołań interfejsu RISC API.

2. Wywołaj API konfiguracji strumienia RISC

Teraz, gdy masz już token autoryzacji, możesz użyć interfejsu API RISC do skonfigurowania strumienia zdarzeń bezpieczeństwa projektu, w tym zarejestrowania punktu końcowego odbiornika.

Aby to zrobić, wyślij żądanie HTTPS POST do https://risc.googleapis.com/v1beta/stream:update , określając punkt końcowy odbiorcy i typy zdarzeń bezpieczeństwa, 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:

Jawa

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

Pyton

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ł pomyślnie skonfigurowany i punkt końcowy odbiornika powinien zacząć odbierać tokeny zdarzeń zabezpieczeń. W następnej sekcji opisano, jak przetestować konfigurację strumienia i punkt końcowy, aby sprawdzić, czy wszystko działa poprawnie.

Pobierz i zaktualizuj swoją aktualną konfigurację strumienia

Jeśli w przyszłości zechcesz zmodyfikować konfigurację strumienia, możesz to zrobić, wysyłając autoryzowane żądanie GET do https://risc.googleapis.com/v1beta/stream , aby uzyskać aktualną konfigurację strumienia, modyfikując treść odpowiedzi , a następnie POST zmodyfikowanej konfiguracji z powrotem do https://risc.googleapis.com/v1beta/stream:update zgodnie z powyższym opisem.

Zatrzymaj i wznów transmisję wydarzeń

Jeśli kiedykolwiek będziesz musiał zatrzymać strumień zdarzeń z Google, wyślij autoryzowane żądanie POST do https://risc.googleapis.com/v1beta/stream/status:update z { "status": "disabled" } w treści żądania. Gdy strumień jest wyłączony, Google nie wysyła zdarzeń do Twojego punktu końcowego i nie buforuje zdarzeń związanych z bezpieczeństwem, gdy się pojawią. Aby ponownie włączyć strumień zdarzeń, POST { "status": "enabled" } do tego samego punktu końcowego.

3. Opcjonalnie: Przetestuj konfigurację strumienia

Możesz sprawdzić, czy konfiguracja strumienia i punkt końcowy odbiornika działają poprawnie, wysyłając token weryfikacyjny za pośrednictwem strumienia zdarzeń. Ten token może zawierać unikalny ciąg, którego można użyć do sprawdzenia, czy token został odebrany w punkcie końcowym.

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

{
  "state": "ANYTHING"
}

Na przykład:

Jawa

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

Pyton

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. Następnie, na przykład, jeśli Twój punkt końcowy obsługuje tokeny weryfikacyjne, po prostu je rejestrując, możesz sprawdzić swoje dzienniki, aby potwierdzić, że token został odebrany.

Odniesienie do kodu błędu

Następujące błędy mogą zostać zwrócone przez RISC API:

Kod błędu Komunikat o błędzie Sugerowane działania
400 Konfiguracja strumienia musi zawierać pole $fieldname . Twoje żądanie skierowane do https://risc.googleapis.com/v1beta/stream:update punktu końcowego jest nieprawidłowe lub nie można go przeanalizować. Prosimy o uwzględnienie $fieldname w swoim zgłoszeniu.
401 Nieautoryzowany. Autoryzacja nie powiodła się. Upewnij się, że do żądania dołączono token autoryzacyjny oraz że token jest ważny i nie wygasł.
403 Punkt końcowy dostarczania musi być adresem URL HTTPS. Punktem końcowym dostarczania (tj. punktem końcowym, do którego mają być dostarczane zdarzenia RISC) musi być protokół HTTPS. Nie wysyłamy zdarzeń RISC do adresów URL HTTP.
403 Istniejąca konfiguracja strumienia nie ma metody dostarczania zgodnej ze specyfikacją dla RISC. Twój projekt Google Cloud musi już mieć konfigurację RISC. Jeśli korzystasz z Firebase i masz włączoną funkcję Logowanie przez Google, Firebase będzie zarządzać ryzykiem RISC Twojego projektu; nie będziesz w stanie utworzyć niestandardowej konfiguracji. Jeśli nie korzystasz z logowania przez Google w swoim projekcie Firebase, wyłącz go, a następnie spróbuj zaktualizować ponownie po godzinie.
403 Nie można znaleźć projektu. Upewnij się, że używasz właściwego konta usługi dla właściwego projektu. 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 redaktora w Twoim projekcie. Przejdź do konsoli Google Cloud Platform swojego projektu i przyznaj kontu usługi, które wykonuje wywołania edytora/właściciela, uprawnienia do projektu, postępując zgodnie z tymi instrukcjami .
403 Interfejsy API zarządzania strumieniami powinny być wywoływane tylko przez konto usługi. Oto więcej informacji na temat wywoływania interfejsów API Google przy użyciu konta usługi .
403 Punkt końcowy dostawy nie należy do żadnej z domen Twojego projektu. Każdy projekt ma zestaw autoryzowanych domen. Jeśli punkt końcowy dostarczania (tj. punkt końcowy, do którego mają być dostarczane zdarzenia RISC) nie jest hostowany na jednym z nich, wymagamy dodania domeny punktu końcowego do tego zestawu.
403 Aby korzystać z tego interfejsu API, w Twoim projekcie musi być skonfigurowany co najmniej jeden klient OAuth. RISC działa tylko wtedy, gdy tworzysz aplikację obsługującą logowanie przez Google . To połączenie wymaga klienta OAuth. Jeśli Twój projekt nie ma klientów OAuth, prawdopodobnie RISC nie będzie dla Ciebie przydatny. Dowiedz się więcej o korzystaniu przez Google z OAuth dla naszych interfejsów API .
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.

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

Dostęp do zakresów tokenów

Jeśli zdecydujesz się użyć tokenów dostępu do uwierzytelniania w interfejsie API RISC, oto zakresy, których musi żądać Twoja aplikacja:

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

Potrzebuję pomocy?

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