Se la tua app consente agli utenti di accedere ai propri account utilizzando Google, puoi migliorare la sicurezza degli account di questi utenti condivisi rimanendo in ascolto e rispondendo alle notifiche di un evento di sicurezza fornite dal servizio Protezione su più account.
Queste notifiche ti avvisano di modifiche importanti agli Account Google dei tuoi utenti, che spesso possono avere anche implicazioni di sicurezza per i loro account con la tua app. Ad esempio, se l'Account Google di un utente venisse compromesso, potrebbe potenzialmente portare alla compromissione dell'account dell'utente con la tua app tramite il recupero dell'account email o l'utilizzo del Single Sign-On.
Per aiutarti a mitigare il rischio potenziale di questi eventi, Google invia al tuo servizio oggetti chiamati token di eventi di sicurezza. Questi token espongono pochissime informazioni, solo il tipo di evento di sicurezza e quando si è verificato, nonché l'identificatore dell'utente interessato, ma puoi utilizzarli per intraprendere l'azione appropriata in risposta. Ad esempio, se l'Account Google di un utente è stato compromesso, puoi disattivare temporaneamente Accedi con Google per quell'utente e impedire l'invio di email di recupero dell'account all'indirizzo Gmail dell'utente.
La protezione su più account si basa sullo standard RISC, sviluppato presso la OpenID Foundation.
Panoramica
Per utilizzare la protezione su più account con la tua app o il tuo servizio, devi completare le seguenti attività:
Configura il progetto nella console API.
Crea un endpoint del ricevitore di eventi, a cui Google invierà i token degli eventi di sicurezza. Questo endpoint è responsabile della convalida dei token che riceve e della risposta agli eventi di sicurezza nel modo che preferisci.
Registra il tuo endpoint con Google per iniziare a ricevere token di eventi di sicurezza.
Prerequisito
Ricevi token di eventi di sicurezza solo per gli utenti Google che hanno concesso al tuo servizio l'autorizzazione ad accedere alle informazioni del loro profilo o ai loro indirizzi email. Puoi ottenere questa autorizzazione richiedendo gli ambiti profile o email. I nuovi SDK Accedi con Google o i precedenti SDK Accedi con Google richiedono questi ambiti per impostazione predefinita, ma se non utilizzi le impostazioni predefinite o se accedi direttamente all'endpoint OpenID Connect di Google, assicurati di richiedere almeno uno di questi ambiti.
Configura un progetto nella console API
Prima di poter iniziare a ricevere token di eventi di sicurezza, devi creare un service account e attivare l'API RISC nel tuo progetto della console API. Devi utilizzare lo stesso progetto della console API che utilizzi per accedere ai servizi Google, come Accedi con Google, nella tua app.
Per creare l'account di servizio:
Apri la pagina Credenziali della console API. Quando richiesto, scegli il progetto della console API che utilizzi per accedere ai servizi Google nella tua app.
Fai clic su Crea credenziali > Service account.
Crea un nuovo service account con il ruolo RISC Configuration Admin (
roles/riscconfigs.admin) seguendo queste istruzioni.(Facoltativo) Se la tua organizzazione Google Cloud consente la creazione di chiavi dei service account e prevedi di firmare i JWT localmente, crea una chiave per il service account appena creato. Scegli il tipo di chiave JSON e fai clic su Crea. Una volta creata la chiave, scaricherai un file JSON contenente le credenziali dell'account di servizio. Conserva questo file in un luogo sicuro, ma anche accessibile all'endpoint del ricevitore di eventi.
Nella pagina Credenziali del progetto, prendi nota anche degli ID client che utilizzi per Accedi con Google o Accedi con Google (legacy). In genere, hai un ID client per ogni piattaforma supportata. Questi ID client ti serviranno per convalidare i token degli eventi di sicurezza, come descritto nella sezione successiva.
Per abilitare l'API RISC:
Apri la pagina dell'API RISC nella console API. Assicurati che il progetto che utilizzi per accedere ai servizi Google sia ancora selezionato.
Leggi i Termini RISC e assicurati di aver compreso i requisiti.
Se stai abilitando l'API per un progetto di proprietà di un'organizzazione, assicurati di avere l'autorizzazione per vincolare la tua organizzazione ai Termini RISC.
Fai clic su Attiva solo se accetti i Termini di RISC.
Crea un endpoint del ricevitore di eventi
Per ricevere notifiche di eventi di sicurezza da Google, devi creare un endpoint HTTPS che gestisca le richieste POST HTTPS. Dopo aver registrato questo endpoint (vedi di seguito), Google inizierà a pubblicare stringhe con firma crittografica chiamate token di eventi di sicurezza nell'endpoint. I token degli eventi di sicurezza sono JWT firmati che contengono informazioni su un singolo evento relativo alla sicurezza.
Per ogni token di evento di sicurezza che ricevi nel tuo endpoint, convalida e decodifica prima il token, poi gestisci l'evento di sicurezza in base al tuo servizio. È essenziale convalidare il token dell'evento prima della decodifica per prevenire attacchi dannosi da parte di malintenzionati. Le sezioni seguenti descrivono queste attività:
1. Decodifica e convalida il token dell'evento di sicurezza
Poiché i token degli eventi di sicurezza sono un tipo specifico di JWT, puoi utilizzare qualsiasi libreria JWT, ad esempio una di quelle elencate su jwt.io, per decodificarli e convalidarli. Indipendentemente dalla libreria utilizzata, il codice di convalida del token deve eseguire le seguenti operazioni:
- Recupera l'identificatore dell'emittente della protezione su più account (
issuer) e l'URI del certificato della chiave di firma (jwks_uri) dal documento di configurazione RISC di Google, che puoi trovare all'indirizzohttps://accounts.google.com/.well-known/risc-configuration. - Utilizzando la libreria JWT che preferisci, recupera l'ID della chiave di firma dall'intestazione del token dell'evento di sicurezza.
- Dal documento del certificato della chiave di firma di Google, recupera la chiave pubblica con l'ID chiave ottenuto nel passaggio precedente. Se il documento non contiene una chiave con l'ID che stai cercando, è probabile che il token dell'evento di sicurezza non sia valido e l'endpoint dovrebbe restituire l'errore HTTP 400.
- Utilizzando la libreria JWT che preferisci, verifica quanto segue:
- Il token dell'evento di sicurezza viene firmato utilizzando la chiave pubblica ottenuta nel passaggio precedente.
- La rivendicazione
auddel token è uno degli ID client delle tue app. - L'attestazione
issdel token corrisponde all'identificatore dell'emittente ottenuto dal documento di rilevamento RISC. Tieni presente che non è necessario verificare la scadenza del token (exp) perché i token degli eventi di sicurezza rappresentano eventi storici e, di conseguenza, non scadono.
Ad esempio:
Java
Utilizzando java-jwt e 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)
Se il token è valido ed è stato decodificato correttamente, restituisci lo stato HTTP 202. Poi, gestisci l'evento di sicurezza indicato dal token.
2. Gestisci gli eventi di sicurezza
Una volta decodificato, un token di evento di sicurezza è simile al seguente esempio:
{
"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"
}
}
}
Le attestazioni iss e aud indicano l'emittente del token (Google) e il destinatario previsto del token (il tuo servizio). Hai verificato queste attestazioni nel passaggio precedente.
La dichiarazione jti è una stringa che identifica un singolo evento di sicurezza ed è univoca per lo stream. Puoi utilizzare questo identificatore per monitorare gli eventi di sicurezza
che hai ricevuto.
La rivendicazione events contiene informazioni sull'evento di sicurezza rappresentato dal token. Questa attestazione è una mappatura da un identificatore del tipo di evento a un'attestazione subject, che specifica l'utente interessato da questo evento e a eventuali dettagli aggiuntivi sull'evento che potrebbero essere disponibili.
La rivendicazione subject identifica un determinato utente con l'ID Account Google univoco dell'utente (sub). Questo ID Account Google è lo stesso identificatore (sub) contenuto nei token ID JWT emessi dalla libreria Accedi con Google più recente (Javascript, HTML), dalla libreria Accedi con Google precedente o da OpenID Connect. Quando il valore subject_type della rivendicazione è id_token_claims, potrebbe includere anche un campo email con l'indirizzo email dell'utente.
Utilizza le informazioni contenute nella rivendicazione events per intraprendere l'azione appropriata per il tipo di evento nell'account dell'utente specificato.
Identificatori dei token OAuth
Per gli eventi OAuth relativi a singoli token, il tipo di identificatore token subject contiene i seguenti campi:
token_type: è supportato solorefresh_token.token_identifier_alg: consulta la tabella seguente per i valori possibili.token: consulta la tabella di seguito.
| token_identifier_alg | token |
|---|---|
prefix |
I primi 16 caratteri del token. |
hash_base64_sha512_sha512 |
Il doppio hash del token utilizzando SHA-512. |
Se esegui l'integrazione con questi eventi, ti consigliamo di indicizzare i token in base a questi possibili valori per garantire una corrispondenza rapida quando l'evento viene ricevuto.
Tipi di eventi supportati
La protezione su più account supporta i seguenti tipi di eventi di sicurezza:
| Tipo di evento | Attributi | Come rispondere |
|---|---|---|
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked |
Obbligatorio: proteggi nuovamente l'account dell'utente terminando le sessioni attualmente aperte. | |
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked |
Obbligatorio: se il token è per Accedi con Google, termina le sessioni attualmente aperte. Inoltre, potresti suggerire all'utente di configurare un metodo di accesso alternativo. Suggerimento: se il token serve per accedere ad altre API di Google, elimina tutti i token OAuth dell'utente che hai memorizzato. |
|
https://schemas.openid.net/secevent/oauth/event-type/token-revoked |
Consulta la sezione Identificatori dei token OAuth per gli identificatori dei token |
Obbligatorio: se memorizzi il token di aggiornamento corrispondente, eliminalo e chiedi all'utente di fornire nuovamente il consenso la prossima volta che sarà necessario un token di accesso. |
https://schemas.openid.net/secevent/risc/event-type/account-disabled |
reason=hijacking,reason=bulk-account |
Obbligatorio: se il motivo per cui l'account è stato disattivato è
Suggerimento: se il motivo per cui l'account è stato disattivato è
Suggerimento: se non è stato fornito alcun motivo, disattiva Accedi con Google per l'utente e disattiva il recupero dell'account utilizzando l'indirizzo email associato all'Account Google dell'utente (di solito, ma non necessariamente, un account Gmail). Offri all'utente un metodo di accesso alternativo. |
https://schemas.openid.net/secevent/risc/event-type/account-enabled |
Suggerimento: riattiva Accedi con Google per l'utente e riattiva il recupero dell'account con l'indirizzo email dell'Account Google dell'utente. | |
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required |
Suggerimento: tieni d'occhio le attività sospette sul tuo servizio e intraprendi le azioni appropriate. | |
https://schemas.openid.net/secevent/risc/event-type/verification |
state=state | Suggerimento: registra la ricezione di un token di test. |
Eventi duplicati e persi
La Protezione su più account tenterà di inviare nuovamente gli eventi che ritiene non siano stati recapitati. Pertanto, a volte potresti ricevere lo stesso evento
più volte. Se ciò potrebbe causare azioni ripetute che creano disagi agli utenti, valuta la possibilità di utilizzare la rivendicazione jti (che è un identificatore univoco di un evento) per deduplicare gli eventi. Esistono strumenti esterni come Google Cloud Dataflow che possono aiutarti a eseguire il flusso di dati di deduplicazione.
Tieni presente che gli eventi vengono inviati con un numero limitato di nuovi tentativi, quindi se il ricevitore non è attivo per un periodo di tempo prolungato, potresti perdere definitivamente alcuni eventi.
Registra il ricevitore
Per iniziare a ricevere eventi di sicurezza, registra l'endpoint del ricevitore utilizzando l'API RISC. Le chiamate all'API RISC devono essere accompagnate da un token di autorizzazione.
Riceverai eventi di sicurezza solo per gli utenti della tua app, quindi devi avere una schermata per il consenso OAuth configurata nel tuo progetto GCP come prerequisito per i passaggi descritti di seguito.
1. Genera un token di autorizzazione
Puoi generare un token di autorizzazione per l'API RISC utilizzando Google Cloud CLI (gcloud) con la simulazione dell'identità dei service account (consigliata quando iam.disableServiceAccountKeyCreation è applicato o per la configurazione una tantum della CLI) o firmando un JWT localmente con una chiave privata del service account.
Opzione A: genera un token di accesso di breve durata utilizzando gcloud (non è richiesta alcuna chiave JSON)
Se il tuo account utente dispone del ruolo Creatore token account di servizio (roles/iam.serviceAccountTokenCreator) nell'account di servizio, puoi generare un token di accesso OAuth 2.0 di breve durata con l'ambito di configurazione RISC richiesto direttamente dal tuo terminale:
AUTH_TOKEN=$(gcloud auth print-access-token \
--impersonate-service-account=SERVICE_ACCOUNT_EMAIL \
--scopes=https://www.googleapis.com/auth/risc.configuration.readwrite,https://www.googleapis.com/auth/risc.verify,https://www.googleapis.com/auth/risc.status.readwrite)
Per ulteriori dettagli sugli ambiti OAuth 2.0 disponibili per l'API RISC, consulta Ambiti dei token di accesso.
Opzione B: crea un JWT autofirmato utilizzando una chiave del service account
In alternativa, per generare un token di autorizzazione localmente senza un round trip di rete, crea un JWT con le seguenti rivendicazioni:
{
"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
}Firma il JWT utilizzando la chiave privata del tuo service account, che puoi trovare nel file JSON scaricato durante la creazione della chiave del service account.
Ad esempio:
Java
Utilizzando java-jwt e la libreria di autenticazione di 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')
Questo token di autorizzazione può essere utilizzato per effettuare chiamate API RISC per un'ora. Quando il token scade, generane uno nuovo per continuare a effettuare chiamate API RISC.
2. Chiama l'API di configurazione dello stream RISC
Ora che hai un token di autorizzazione, puoi utilizzare l'API RISC per configurare lo stream di eventi di sicurezza del tuo progetto, inclusa la registrazione dell'endpoint del ricevitore.
Per farlo, invia una richiesta POST HTTPS a https://risc.googleapis.com/v1beta/stream:update, specificando l'endpoint del ricevitore e i tipi di eventi di sicurezza che ti interessano:
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
]
}
Ad esempio:
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'])
Se la richiesta restituisce HTTP 200, lo stream di eventi è stato configurato correttamente e l'endpoint del ricevitore dovrebbe iniziare a ricevere i token degli eventi di sicurezza. La sezione successiva descrive come testare la configurazione dello stream e l'endpoint per verificare che tutto funzioni correttamente.
Recupera e aggiorna la configurazione attuale dello stream
Se in futuro vuoi modificare la configurazione dello stream, puoi farlo inviando una richiesta GET autorizzata a https://risc.googleapis.com/v1beta/stream per ottenere la configurazione dello stream corrente, modificando il corpo della risposta e inviando la configurazione modificata a https://risc.googleapis.com/v1beta/stream:update come descritto sopra.
Interrompi e riprendi il flusso di eventi
Se hai bisogno di interrompere lo stream di eventi da Google, invia una richiesta POST autorizzata a https://risc.googleapis.com/v1beta/stream/status:update con { "status": "disabled" } nel corpo della richiesta. Mentre lo stream è disattivato, Google non invia eventi al tuo endpoint e non memorizza nel buffer gli eventi di sicurezza quando si verificano. Per riattivare lo stream di eventi, invia una richiesta POST { "status": "enabled" } allo stesso endpoint.
3. (Facoltativo) Testa la configurazione dello stream
Puoi verificare che la configurazione dello stream e l'endpoint del ricevitore funzionino correttamente insieme inviando un token di verifica tramite lo stream di eventi. Questo token può contenere una stringa univoca che puoi utilizzare per verificare che il token sia stato ricevuto dal tuo endpoint. Per utilizzare questo flusso, assicurati di iscriverti al tipo di evento https://schemas.openid.net/secevent/risc/event-type/verification quando registri il ricevitore.
Per richiedere un token di verifica, invia una richiesta POST HTTPS autorizzata a https://risc.googleapis.com/v1beta/stream:verify. Nel corpo della richiesta, specifica una stringa identificativa:
{
"state": "ANYTHING"
}
Ad esempio:
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()))
Se la richiesta va a buon fine, il token di verifica verrà inviato all'endpoint che hai registrato. Ad esempio, se l'endpoint gestisce i token di verifica semplicemente registrandoli, puoi esaminare i log per confermare che il token è stato ricevuto.
Messaggio del codice di errore
L'API RISC può restituire i seguenti errori:
| Codice di errore | Messaggio di errore | Azioni suggerite |
|---|---|---|
| 400 | La configurazione dello stream deve contenere il campo $fieldname. | La tua richiesta all'endpoint https://risc.googleapis.com/v1beta/stream:update non è valida o non può essere analizzata. Includi $fieldname nella richiesta. |
| 401 | Non autorizzato. | Autorizzazione negata. Assicurati di aver allegato un token di autorizzazione alla richiesta e che il token sia valido e non sia scaduto. |
| 403 | L'endpoint di distribuzione deve essere un URL HTTPS. | L'endpoint di distribuzione (ovvero l'endpoint a cui prevedi che vengano recapitati gli eventi RISC) deve essere HTTPS. Non inviamo eventi RISC a URL HTTP. |
| 403 | La configurazione dello stream esistente non ha un metodo di pubblicazione conforme alle specifiche per RISC. | Il tuo progetto Google Cloud deve già avere una configurazione RISC. Se utilizzi Firebase e hai attivato Accedi con Google, Firebase gestirà RISC per il tuo progetto; non potrai creare una configurazione personalizzata. Se non utilizzi Accedi con Google per il tuo progetto Firebase, disattivalo e riprova ad aggiornare dopo un'ora. |
| 403 | Impossibile trovare il progetto. | Assicurati di utilizzare il service account corretto per il progetto corretto. Potresti utilizzare un service account associato a un progetto eliminato. Scopri come visualizzare tutti i service account associati a un progetto. |
| 403 | Il service account deve disporre dell'autorizzazione per accedere alla tua configurazione RISC | Vai alla console API del tuo progetto e assegna il ruolo "RISC Configuration Admin" (roles/riscconfigs.admin) al service account che effettua le chiamate al tuo progetto seguendo queste istruzioni.
|
| 403 | Le API di gestione degli stream devono essere chiamate solo da un service account. | Ecco ulteriori informazioni su come chiamare le API di Google con un service account. |
| 403 | L'endpoint di distribuzione non appartiene a nessuno dei domini del tuo progetto. | Ogni progetto ha un insieme di domini autorizzati. Se il tuo endpoint di distribuzione (ovvero l'endpoint a cui prevedi che vengano recapitati gli eventi RISC) non è ospitato su uno di questi, devi aggiungere il dominio dell'endpoint a questo insieme. |
| 403 | Per utilizzare questa API, il tuo progetto deve avere almeno un client OAuth configurato. | RISC funziona solo se crei un'app che supporta Accedi con Google. Questa connessione richiede un client OAuth. Se il tuo progetto non ha client OAuth, è probabile che RISC non ti sia utile. Scopri di più sull'utilizzo di OAuth da parte di Google per le nostre API. |
| 403 |
Stato non supportato. Stato non valido. |
Al momento supportiamo solo gli stati dello stream "enabled" e
"disabled". |
| 404 |
Il progetto non ha una configurazione RISC. Il progetto non ha una configurazione RISC esistente, impossibile aggiornare lo stato. |
Chiama l'endpoint https://risc.googleapis.com/v1beta/stream:update per creare una nuova configurazione dello stream. |
| 4XX/5XX | Impossibile aggiornare lo stato. | Per saperne di più, controlla il messaggio di errore dettagliato. |
Ambiti dei token di accesso
Se decidi di utilizzare i token di accesso per l'autenticazione all'API RISC, questi sono gli ambiti che la tua applicazione deve richiedere:
| Endpoint | Ambito |
|---|---|
https://risc.googleapis.com/v1beta/stream/status |
https://www.googleapis.com/auth/risc.status.readonly
OPPURE 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
OPPURE 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 |
Serve aiuto?
Innanzitutto, consulta la sezione Riferimento ai codici di errore. Se hai ancora domande, pubblicale su Stack Overflow con il tag #SecEvents.