Jeśli Twoja aplikacja umożliwia użytkownikom logowanie się na konta przez Google, możesz: bezpieczeństwo użytkowników, których współdzielą kont, nasłuchując i odpowiadając powiadomień o zdarzeniach związanych z bezpieczeństwem udostępnianych przez usługę ochrony wszystkich kont.
Powiadomienia te informują o ważnych zmianach na Twoim koncie Google użytkowników, co często może mieć wpływ na bezpieczeństwo ich kont, do aplikacji. Jeśli na przykład ktoś włamie się na konto Google, potencjalnie dopuścić do włamania na konto użytkownika powiązanego z Twoją aplikacją e-mailem. odzyskiwania konta i korzystania z logowania jednokrotnego.
Aby pomóc Ci zmniejszyć ryzyko wystąpienia takich zdarzeń, Google wysyła Twoją obiektów usługi nazywanych tokenami zdarzeń związanych z bezpieczeństwem. Te tokeny ujawniają bardzo mało informacje – tylko typ zdarzenia związanego z bezpieczeństwem i czas jego wystąpienia, a także użytkownika, którego dotyczy problem, ale możesz go użyć, odpowiednie działania w odpowiedzi. Jeśli na przykład konto Google użytkownika zostało przejętego, możesz tymczasowo wyłączyć funkcję Zaloguj się przez Google dla tego użytkownika oraz zapobiega wysyłaniu e-maili dotyczących odzyskiwania konta na adres Gmail użytkownika.
Ochrona wszystkich kont opiera się na standard RISC opracowany w OpenID Foundation.
Omówienie
Aby korzystać z Ochrony wszystkich kont w swojej aplikacji lub usłudze, musisz wykonać następujące zadania:
Skonfiguruj projekt w: API Console.
Utwórz punkt końcowy odbiorcy zdarzeń, do którego Google będzie wysyłać zdarzenie związane z bezpieczeństwem tokeny. Ten punkt końcowy odpowiada za weryfikację otrzymanych tokenów a następnie reagować na zdarzenia związane z bezpieczeństwem w dowolny sposób.
Aby zacząć otrzymywać tokeny zdarzeń związanych z bezpieczeństwem, zarejestruj punkt końcowy w Google.
Warunek wstępny
Tokeny zdarzeń związanych z bezpieczeństwem otrzymasz tylko w przypadku użytkowników Google, którzy udzielili
dostępu do informacji profilowych lub adresów e-mail użytkowników. Ty
uzyskać to uprawnienie, wysyłając żądanie o zakresy profile lub email. Nowsza
Zaloguj się przez Google lub starszą wersję aplikacji,
Pakiety SDK logowania przez Google domyślnie żądają tych zakresów, ale
jeśli nie używasz ustawień domyślnych lub korzystasz z identyfikatora OpenID Google
Połącz punkt końcowy bezpośrednio. Sprawdź,
wysyłasz żądanie co najmniej 1 z tych zakresów.
Skonfiguruj projekt w API Console
Zanim zaczniesz otrzymywać tokeny zdarzeń związanych z bezpieczeństwem, musisz utworzyć usługę i włącz interfejs RISC API w API Console . Musisz użyć tego samego API Console projekt, którego używasz usług Google, takich jak Logowanie przez Google, w Twojej aplikacji.
Aby utworzyć konto usługi:
Otwórz API Console Credentials page. Gdy pojawi się odpowiedni komunikat, wybierz API Console projektu, którego używasz do uzyskiwania dostępu do usług Google w swojej aplikacji.
Kliknij Utwórz dane logowania > Konto usługi.
Utwórz nowe konto usługi z rolą administratora konfiguracji RISC (
roles/riscconfigs.admin) przez obserwowanie tymi instrukcjami.Utwórz klucz dla nowo utworzonego konta usługi. Wybierz klucz JSON i kliknij Utwórz. Podczas tworzenia klucza pobierzesz plik JSON zawierający Twoje konto usługi, dane logowania. Przechowuj ten plik w bezpiecznym miejscu, ale ma też dostęp do: punktu końcowego odbiorcy zdarzeń.
Będąc w projekcie, zanotuj też nazwę klienta. Identyfikatory, których używasz na potrzeby funkcji Zaloguj się przez Google lub Logowanie przez Google (starsza wersja). Zwykle dla każdej aplikacji jest podany identyfikator klienta platformy, w której się uczysz. Te identyfikatory klientów będą potrzebne do weryfikacji zdarzenia związanego z bezpieczeństwem tokeny, jak opisano w następnej sekcji.
Aby włączyć interfejs RISC API:
Otwórz stronę RISC API w API ConsoleSprawdź, czy używany przez Ciebie projekt aby uzyskać dostęp do usług Google.
Przeczytaj Warunki RISC i upewnij się, że rozumiesz wymagania.
Jeśli włączasz interfejs API w projekcie należącym do organizacji, sprawdź, masz upoważnienie do związania swojej organizacji Warunkami RISC.
Kliknij Włącz tylko wtedy, gdy wyrażasz zgodę na Warunki RISC.
Tworzenie punktu końcowego odbiorcy zdarzeń
Aby otrzymywać od Google powiadomienia o zdarzeniach związanych z bezpieczeństwem, utwórz punkt końcowy HTTPS który obsługuje żądania HTTPS POST. Po zarejestrowaniu tego punktu końcowego (patrz poniżej) Google zacznie publikować podpisane kryptograficznie ciągi znaków nazywane zdarzeniem bezpieczeństwa tokeny w punkcie końcowym. Tokeny zdarzeń zabezpieczeń to podpisane tokeny JWT, które zawierają informacji na temat pojedynczego zdarzenia związanego z bezpieczeństwem.
W przypadku każdego tokena zdarzenia związanego z bezpieczeństwem otrzymanego w punkcie końcowym najpierw zweryfikuj zdekodować token, a następnie obsługiwać zdarzenie związane z bezpieczeństwem odpowiednio posprzedażna. Konieczne jest zweryfikowanie tokena zdarzenia przed dekodowaniem, aby zapobiec złośliwe ataki ze strony nieuczciwych podmiotów. Zadania te są opisane w sekcjach poniżej:
1. Dekodowanie i weryfikowanie tokena zdarzenia związanego z bezpieczeństwem
Tokeny zdarzeń zabezpieczeń to specjalny rodzaj tokenów JWT, więc możesz używać dowolnego biblioteka JWT, np. wymieniona na jwt.io, do dekodowania i ich potwierdzenie. Niezależnie od używanej biblioteki, kod weryfikacyjny tokena musi wykonać :
- Pobieranie identyfikatora wydawcy Ochrony wszystkich kont (
issuer) i klucza podpisywania identyfikator URI certyfikatu (jwks_uri) z dokumentu konfiguracji RISC od Google, które znajdziesz nahttps://accounts.google.com/.well-known/risc-configuration - Korzystając z wybranej biblioteki JWT, pobierz identyfikator klucza podpisywania z nagłówka tokena zdarzenia związanego z bezpieczeństwem.
- Z dokumentu certyfikatu klucza podpisywania Google pobierz klucz publiczny z identyfikatora klucza uzyskany w poprzednim kroku. Jeśli dokument nie zawiera klucza o identyfikatorze, którego szukasz, prawdopodobnie token zdarzenia związanego z bezpieczeństwem jest nieprawidłowy i punkt końcowy powinien zwracać błąd HTTP 400.
- Korzystając z wybranej biblioteki JWT, sprawdź, czy:
- Token zdarzenia związanego z bezpieczeństwem jest podpisany za pomocą klucza publicznego uzyskanego w poprzedniego kroku.
- Deklaracja
audtokena jest jedną z Twoich aplikacji identyfikatorów klientów. - Deklaracja
isstokena pasuje do identyfikatora wydawcy, od którego uzyskano dostęp dokument opisujący RISC. Nie musisz weryfikować daty ważności tokena (exp), ponieważ Tokeny zdarzeń związanych z bezpieczeństwem reprezentują zdarzenia historyczne, więc nie wygasają.
Na przykład:
Java
Używanie biblioteki 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ł zdekodowany, zwracaj stan HTTP 202. Następnie przetwórz zdarzenie związane z bezpieczeństwem wskazane przez token.
2. Obsługa zdarzeń związanych z bezpieczeństwem
Po zdekodowaniu token zdarzenia związanego z bezpieczeństwem wygląda tak:
{
"iss": "https://accounts.google.com/",
"aud": "123456789-abcedfgh.apps.googleusercontent.com",
"iat": 1508184845,
"jti": "756E69717565206964656E746966696572",
"events": {
"https://schemas.openid.net/secevent/risc/event-type/account-disabled": {
"subject": {
"subject_type": "iss-sub",
"iss": "https://accounts.google.com/",
"sub": "7375626A656374"
},
"reason": "hijacking"
}
}
}
Deklaracje iss i aud wskazują wystawcę tokena (Google) i tag
docelowego odbiorcy tokena (Twojej usługi). Te roszczenia zostały przez Ciebie zweryfikowane w
poprzedniego kroku.
Deklaracja jti to ciąg znaków, który identyfikuje pojedyncze zdarzenie związane z bezpieczeństwem.
tylko w przypadku danego strumienia. Możesz użyć tego identyfikatora do śledzenia, które zdarzenia związane z bezpieczeństwem
otrzymanych przez Ciebie.
Deklaracja events zawiera informacje o zdarzeniu związanym z bezpieczeństwem tokena
co reprezentuje. Ta rezerwacja to mapowanie z identyfikatora typu zdarzenia na subject
twierdzenia, które wskazuje użytkownika, którego dotyczy to zdarzenie, oraz do wszelkich dodatkowych
szczegóły wydarzenia, które mogą być dostępne.
Deklaracja subject identyfikuje konkretnego użytkownika za pomocą jego unikalnego identyfikatora Google
Identyfikator konta (sub). Ten identyfikator konta Google jest identycznym z identyfikatorem (sub) podanym w tabeli
w tokenach identyfikatora JWT wystawionych przez nowszą funkcję Zaloguj się przez Google (JavaScript
, biblioteki HTML), starszą bibliotekę Logowanie przez Google lub
OpenID Connect. Gdy w tagu subject_type
twierdzenie to id_token_claims, może też zawierać pole email z
adres e-mail użytkownika.
Użyj informacji z roszczenia events, aby podjąć odpowiednie działania w odniesieniu do
na koncie określonego użytkownika.
Identyfikatory tokenów OAuth
W przypadku zdarzeń OAuth dotyczących poszczególnych tokenów typ identyfikatora tematu tokena zawiera te pola:
token_type: obsługiwana jest tylko wartośćrefresh_token.token_identifier_alg: możliwe wartości znajdziesz w tabeli poniżej.token: patrz tabela poniżej.
| token_identifier_alg | token |
|---|---|
prefix |
Pierwsze 16 znaków tokena. |
hash_base64_sha512_sha512 |
Podwójny hasz tokena z użyciem SHA-512. |
Jeśli przeprowadzisz integrację z tymi zdarzeniami, zalecamy indeksowanie tokenów na podstawie tych możliwych wartości, aby zapewnić szybkie dopasowanie po otrzymaniu zdarzenia.
Obsługiwane typy zdarzeń
Ochrona wszystkich kont obsługuje te typy zdarzeń związanych z bezpieczeństwem:
| Typ zdarzenia | Atrybuty | Jak odpowiadać |
|---|---|---|
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked |
Wymagane: ponownie zabezpiecz konto użytkownika, kończąc bieżące sesji otwartych. | |
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked |
Wymagane: jeśli token jest przeznaczony do Logowanie przez Google, zakończ jego aktualnie otwartych sesji. Możesz także zasugerować użytkownikowi, skonfigurować alternatywną metodę logowania. Sugerowane: jeśli token służy do uzyskiwania dostępu do innych interfejsów API Google, usuń wszystkich zapisanych tokenów OAuth użytkownika. |
|
https://schemas.openid.net/secevent/oauth/event-type/token-revoked |
W sekcji Identyfikatory tokenów OAuth znajdziesz informacje identyfikatory tokenów |
Wymagane: jeśli przechowujesz odpowiedni token odświeżania, usuń go. i poprosić użytkownika o ponowne wyrażenie zgody, gdy potrzebny będzie 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
Sugerowane: jeśli konto zostało wyłączone
Sugerowane: jeśli nie podano powodu, wyłącz Logowanie przez Google w przypadku użytkownika i wyłącz odzyskiwanie konta przy użyciu adresu e-mail powiązanego z konto Google użytkownika (zwykle, ale niekoniecznie jest to konto Gmail). Zaoferuj użytkownikowi alternatywną metodę logowania. |
https://schemas.openid.net/secevent/risc/event-type/account-enabled |
Sugerowane: jeszcze raz włącz Logowanie przez Google na koncie użytkownika, a następnie włącz je ponownie odzyskiwania konta przy użyciu adresu e-mail konta Google użytkownika. | |
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required |
Sugerowane: Uważaj na podejrzaną aktywność w Twojej usłudze i wykonaj odpowiednie działania. | |
https://schemas.openid.net/secevent/risc/event-type/verification |
state=state | Sugerowane: loguje, że otrzymano token testowy. |
Zduplikowane i pominięte wydarzenia
Ochrona wszystkich kont będzie próbowała ponownie przesłać zdarzenia, które według jej prognozy
nie dostarczono. Dlatego czasami to samo zdarzenie
wiele razy. Jeśli spowoduje to powtarzające się działania, które w efekcie
użytkowników, możesz użyć deklaracji jti (która jest unikalnym identyfikatorem
), aby usunąć duplikaty zdarzeń. Są to narzędzia zewnętrzne, takie jak Google Cloud
Dataflow, która może ułatwić wykonanie
do usuwania duplikatów w Dataflow.
Pamiętaj, że wydarzenia są dostarczane z ograniczoną liczbą ponownych prób, więc jeśli odbiornik jest niedostępny. przez dłuższy czas możesz trwale przegapić niektóre wydarzenia.
Zarejestruj odbiornik
Aby zacząć odbierać zdarzenia związane z bezpieczeństwem, zarejestruj punkt końcowy odbiorcy za pomocą RISC API. Wywołaniom do interfejsu RISC API musi towarzyszyć token autoryzacji.
Będziesz otrzymywać zdarzenia związane z bezpieczeństwem tylko dla użytkowników Twojej aplikacji, dlatego musisz skonfigurować ekran zgody OAuth w projekcie GCP. Jest to wymagane do wykonania kroków opisanych poniżej.
1. Generowanie tokena autoryzacji
Aby wygenerować token autoryzacji dla interfejsu RISC API, utwórz token JWT z następujące stwierdzenia:
{
"iss": SERVICE_ACCOUNT_EMAIL,
"sub": SERVICE_ACCOUNT_EMAIL,
"aud": "https://risc.googleapis.com/google.identity.risc.v1beta.RiscManagementService",
"iat": CURRENT_TIME,
"exp": CURRENT_TIME + 3600
}Podpisz JWT za pomocą klucza prywatnego konta usługi, który znajdziesz w Plik JSON pobrany podczas tworzenia klucza konta usługi.
Na przykład:
Java
Przy użyciu biblioteki java-jwt i Biblioteka 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 RISC API przez 1 godzinę. Kiedy token wygaśnie, wygeneruj nowy, aby nadal wykonywać wywołania interfejsu RISC API.
2. Wywoływanie interfejsu API konfiguracji strumienia RISC
Teraz gdy masz już token autoryzacji, możesz użyć interfejsu RISC API, aby skonfigurować strumienia zdarzeń związanych z bezpieczeństwem projektu, w tym rejestrowania odbiornika punktu końcowego.
Aby to zrobić, wyślij żądanie HTTPS POST do https://risc.googleapis.com/v1beta/stream:update,
określenie punktu końcowego odbiorcy i typów zabezpieczeń,
wydarzenia, które Cię interesują:
POST /v1beta/stream:update HTTP/1.1
Host: risc.googleapis.com
Authorization: Bearer AUTH_TOKEN
{
"delivery": {
"delivery_method":
"https://schemas.openid.net/secevent/risc/delivery-method/push",
"url": RECEIVER_ENDPOINT
},
"events_requested": [
SECURITY_EVENT_TYPES
]
}
Na przykład:
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 kod HTTP 200, oznacza to, że strumień zdarzeń został skonfigurowany. a punkt końcowy odbiorcy powinien zacząć otrzymywać tokeny zdarzeń związanych z bezpieczeństwem. następna sekcja opisuje, jak przetestować konfigurację strumienia i punkt końcowy. aby sprawdzić, czy wszystko działa poprawnie.
Pobieranie i aktualizowanie bieżącej konfiguracji strumienia
Jeśli w przyszłości zechcesz zmienić konfigurację transmisji,
więc wysyłając autoryzowane żądanie GET do usługi https://risc.googleapis.com/v1beta/stream,
bieżącą konfigurację strumienia, zmodyfikować treść odpowiedzi, a następnie wysłać
z powrotem zmodyfikowano konfigurację do https://risc.googleapis.com/v1beta/stream:update w sposób opisany powyżej.
Zatrzymywanie i wznawianie transmisji wydarzenia
Jeśli kiedykolwiek zechcesz zatrzymać strumień wydarzeń z Google, wykonaj autoryzowane żądanie POST
prośba do: https://risc.googleapis.com/v1beta/stream/status:update za pomocą: { "status": "disabled" }
w treści żądania. Gdy strumień jest dezaktywowany, Google nie wysyła zdarzeń
do punktu końcowego i nie buforuje zdarzeń związanych z bezpieczeństwem, gdy wystąpią. Do
ponownie włącz strumień zdarzeń, POST { "status": "enabled" } w tym samym punkcie końcowym.
3. Opcjonalnie: testowanie konfiguracji strumienia
Możesz sprawdzić, czy konfiguracja strumienia i punkt końcowy odbiorcy działają poprawnie, wysyłając token weryfikacyjny w strumieniu zdarzeń. Może on zawierać unikalny ciąg znaków, za pomocą którego można sprawdzić, czy odebrano token w punkcie końcowym. Aby skorzystać z tej procedury, zasubskrybuj https://schemas.openid.net/secevent/risc/event-type/verification typ zdarzenia podczas rejestrowania odbiornika.
Aby poprosić o token weryfikacyjny, wyślij autoryzowane żądanie HTTPS POST do
https://risc.googleapis.com/v1beta/stream:verify W treści żądania określ
ciąg identyfikujący:
{
"state": "ANYTHING"
}
Na przykład:
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 punktu końcowego zarejestrowano. Następnie, jeśli punkt końcowy obsługuje tokeny weryfikacyjne przez można sprawdzić w dziennikach, czy token odebrane.
Odniesienie do kodu błędu
Interfejs RISC API może zwrócić te błędy:
| Kod błędu | Komunikat o błędzie | Sugerowane działania |
|---|---|---|
| 400, | Konfiguracja strumienia musi zawierać pole $fieldname. | Żądanie do punktu końcowego https://risc.googleapis.com/v1beta/stream:update jest nieprawidłowe lub nie można go przeanalizowano. W swojej prośbie umieść pole $fieldname. |
| 401, | Brak autoryzacji. | Autoryzacja nie powiodła się. Pamiętaj, aby dołączyć dokument token autoryzacji z żądaniem i że token jest prawidłowy. i nie wygasła. |
| 403, | Punkt końcowy dostarczania musi być adresem URL HTTPS. | Punkt końcowy dostarczania (tj. punkt końcowy, w którym spodziewasz się zdarzeń RISC) do) musi być protokołem HTTPS. Nie wysyłamy zdarzeń RISC do adresów URL HTTP. |
| 403, | Istniejąca konfiguracja strumienia nie ma wyświetlania zgodnej ze 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, Firebase zarządzanie RISC w projekcie; nie będziesz mieć możliwości utworzenia konfiguracji. Jeśli w swoim projekcie Firebase nie używasz Logowania przez Google, wyłącz ją, a następnie spróbuj zaktualizować ponownie za godzinę. |
| 403, | Nie udało się znaleźć projektu. | Upewnij się, że używasz konta usługi dla właściwego w projektach AI. Możliwe, że używasz konta usługi powiązanego z usuniętym kontem w projektach AI. Ucz się jak wyświetlić wszystkie konta usługi powiązane z projektem. |
| 403, | Konto usługi wymaga uprawnień dostępu do RISC konfiguracja | Otwórz API Console i
przypisz rolę administratora konfiguracji RISC. rola
(roles/riscconfigs.admin)
z kontem usługi, które wywołuje Twój projekt, przez
obserwujesz
tymi instrukcjami.
|
| 403, | Interfejsy API do zarządzania strumieniem powinny być wywoływane tylko przez konto usługi. | Tutaj znajdziesz więcej informacji na temat: 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 tylko w przypadku autoryzowanych domen. Jeśli punkt końcowy dostarczania (tj. punkt końcowy, w którym oczekujesz zdarzeń RISC do której nie jest hostowany, musisz dodać domeny punktu końcowego do tego zbioru. |
| 403, | Aby można było używać tego interfejsu API, projekt musi mieć skonfigurowany co najmniej 1 klienta OAuth. | RISC działa tylko wtedy, gdy tworzysz aplikację, która obsługuje Logowanie przez Google To połączenie wymaga klienta OAuth. Jeśli Twój projekt nie ma protokołu OAuth rozwiązanie RISC prawdopodobnie nie będzie dla Ciebie przydatne. Więcej informacji o korzystaniu z protokołu OAuth przez Google dla naszych interfejsów API. |
| 403, |
Stan nieobsługiwany. Nieprawidłowy stan. |
Obsługujemy tylko stany transmisji „enabled” oraz
„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ę używać tokenów dostępu do uwierzytelniania w interfejsie RISC API, to zakresy, do których aplikacja musi prosić:
| 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 informacjami o kodach błędów. Jeśli nadal ma pytania, publikuj je na Stack Overflow #SecEvents .