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:
Skonfiguruj projekt w: API Console.
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.
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:
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.
Kliknij Utwórz dane logowania > Konto usługi.
Utwórz nowe konto usługi z rolą administratora konfiguracji RISC (
roles/riscconfigs.admin), postępując zgodnie z tymi instrukcjami.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:
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.
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.
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:
- 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. - Korzystając z wybranej biblioteki JWT, uzyskaj identyfikator klucza podpisywania z nagłówka tokena zdarzenia związanego z bezpieczeństwem.
- 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.
- 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
audtokena jest jednym z identyfikatorów klienta aplikacji. - Żądanie
isstokena 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:
Java
Użycie poleceń 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 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 opcjarefresh_token.token_identifier_alg: możliwe wartości znajdziesz w tabeli poniżej.token: patrz tabela poniżej.
| token_identifier_alg, | token |
|---|---|
prefix |
Pierwsze 16 znaków tokena. |
hash_base64_sha512_sha512 |
Podwójny hasz tokena tokena SHA-512. |
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:
| Typ zdarzenia | Atrybuty | Jak odpowiadać |
|---|---|---|
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked |
Wymagane: ponownie zabezpiecz konto użytkownika, zamykając jego otwarte sesje. | |
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked |
Wymagane: jeśli token dotyczy logowania przez Google, zakończ otwarte sesje. Możesz także zaproponować użytkownikowi skonfigurowanie innej metody logowania. Zalecane: jeśli token dotyczy dostępu do innych interfejsów Google API, usuń wszystkie przechowywane tokeny OAuth użytkownika. |
|
https://schemas.openid.net/secevent/oauth/event-type/token-revoked |
Informacje o identyfikatorach tokenów znajdziesz w sekcji Identyfikatory protokołu OAuth |
Wymagane: jeśli przechowujesz odpowiedni token odświeżania, usuń go i poproś użytkownika o ponowne wyrażenie zgody następnym razem, gdy będzie potrzebny token dostępu. |
https://schemas.openid.net/secevent/risc/event-type/account-disabled |
reason=hijacking,reason=bulk-account |
Wymagane: jeśli konto zostało wyłączone z powodu Sugerowane: jeśli przyczyną wyłączenia konta było Sugerowane: jeśli nie podano powodu, wyłącz logowanie przez Google dla użytkownika i wyłącz odzyskiwanie konta przy użyciu adresu e-mail powiązanego z kontem Google tego użytkownika (zwykle nie jest to konto Gmail). Udostępnij użytkownikowi alternatywną metodę logowania. |
https://schemas.openid.net/secevent/risc/event-type/account-enabled |
Zalecane: włącz ponownie Logowanie przez Google dla użytkownika i ponownie włącz odzyskiwanie konta 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 zapewnij mu alternatywną metodę logowania. | |
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required |
Sugerowane: uważaj na podejrzaną aktywność w swojej usłudze i podejmuj odpowiednie działania. | |
https://schemas.openid.net/secevent/risc/event-type/verification |
stan=state | Sugerowane: zapisz, że otrzymano token testowy. |
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:
Java
Korzystanie z biblioteki 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;
}
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 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:
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 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:
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 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:
| Kod błędu | Komunikat o błędzie | Sugerowane działania |
|---|---|---|
| 400 | Konfiguracja strumienia musi zawierać pole $fieldname. | Twoje żądanie 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ę. Pamiętaj, aby dołączyć do żądania token autoryzacji oraz czy 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 mają być dostarczane zdarzenia RISC) musi korzystać z HTTPS. Zdarzenia RISC nie są wysyłane na adresy URL HTTP. |
| 403 | Istniejąca konfiguracja strumienia nie ma metody wyświetlania zgodnej z specyfikacją dla RISC. | Twój projekt Google Cloud musi mieć już konfigurację RISC. Jeśli korzystasz z Firebase i masz włączone Logowanie przez Google, to usługa Firebase będzie zarządzać funkcją RISC w Twoim projekcie. Nie będzie można utworzyć konfiguracji niestandardowej. Jeśli nie korzystasz z Logowania przez Google w projekcie Firebase, wyłącz go, a po godzinie spróbuj jeszcze raz dokonać aktualizacji. |
| 403 | Nie udało się znaleźć projektu. | Sprawdź, czy 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 potrzebuje uprawnień dostępu do konfiguracji RISC | Otwórz projekt API Console i przypisz rolę „Administrator konfiguracji RISC” (roles/riscconfigs.admin) do konta usługi, które wywołuje Twój projekt, zgodnie z tymi instrukcjami.
|
| 403 | Interfejsy API zarządzania strumieniem powinny być wywoływane tylko przez konto usługi. | Dowiedz się więcej o tym, jak wywoływać interfejsy API Google za pomocą konta usługi. |
| 403 | Punkt końcowy dostarczania nie należy do żadnej z domen Twojego projektu. | Każdy projekt ma zestaw autoryzowanych domen. Jeśli Twój punkt końcowy dostarczania (czyli punkt końcowy, do którego mają być dostarczane zdarzenia RISC) nie jest hostowany w jednym z nich, musisz dodać do niego domenę punktu końcowego. |
| 403 | Aby korzystać z tego interfejsu API, w projekcie musi być skonfigurowany co najmniej jeden klient OAuth. | RISC działa tylko wtedy, gdy stworzysz aplikację obsługującą Logowanie przez Google. To połączenie wymaga klienta OAuth. Jeśli Twój projekt nie ma klientów OAuth, RISC może nie być dla Ciebie przydatne. Dowiedz się więcej o korzystaniu przez Google z protokołu OAuth przez nasze interfejsy API. |
| 403 |
Nieobsługiwany stan. Nieprawidłowy stan. |
Obecnie obsługujemy tylko stany transmisji „enabled” i „disabled”. |
| 404 |
Projekt nie ma konfiguracji RISC. Projekt nie ma istniejącej konfiguracji RISC. Nie można zaktualizować stanu. |
Wywołaj punkt końcowy https://risc.googleapis.com/v1beta/stream:update, aby utworzyć nową konfigurację strumienia. |
| 4XX/5XX | Nie można zaktualizować stanu. | Więcej informacji znajdziesz w szczegółowym komunikacie 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, aplikacja musi uzyskać 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, zadaj je na stronie Stack Overflow za pomocą tagu #SecEvents.