Se la tua app consente agli utenti di accedere ai propri account utilizzando Google, puoi migliorare la sicurezza degli account di questi utenti condivisi ascoltando e rispondendo alle notifiche degli eventi di sicurezza fornite dal servizio Protezione su più account.
Queste notifiche ti avvisano di modifiche importanti agli Account Google dei tuoi utenti, il che spesso può avere ripercussioni anche sulla sicurezza dei loro account con la tua app. Ad esempio, la compromissione dell'Account Google di un utente potrebbe comportare la compromissione dell'account dell'utente con la tua app tramite il recupero dell'account email o l'uso del Single Sign-On.
Per aiutarti a ridurre il potenziale di rischio di questi eventi, Google invia i tuoi oggetti di servizio denominati token evento di sicurezza. Questi token espongono pochissime informazioni, solo il tipo e il momento in cui si è verificato l'evento di sicurezza, nonché l'identificatore dell'utente interessato, ma puoi utilizzarli per intraprendere azioni appropriate in risposta. Ad esempio, se l'Account Google di un utente è stato compromesso, puoi disattivare temporaneamente Accedi con Google per quell'utente e impedire che le email di recupero dell'account vengano inviate all'indirizzo Gmail dell'utente.
La Protezione su più account si basa sullo standard RISC, sviluppato presso 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 in API Console.
Creare un endpoint ricevitore di eventi a cui Google invierà i token degli eventi di sicurezza. Questo endpoint è responsabile della convalida dei token che riceve e quindi della risposta agli eventi di sicurezza in qualsiasi modo tu scelga.
Registra il tuo endpoint con Google per iniziare a ricevere i token degli eventi di sicurezza.
Prerequisito
Riceverai i token evento di sicurezza solo per gli utenti Google che hanno concesso alla tua
autorizzazione di accesso al servizio le informazioni del profilo o gli indirizzi email. Per ottenere questa autorizzazione, richiedi gli ambiti profile o email. I più recenti SDK Accedi con Google o Accedi con Google richiedono questi ambiti per impostazione predefinita, ma se non utilizzi le impostazioni predefinite o se accedi direttamente all'endpoint di OpenID Connect di Google, assicurati di richiedere almeno uno di questi ambiti.
Configura un progetto in API Console
Prima di poter iniziare a ricevere i token degli eventi di sicurezza, devi creare un account di servizio e attivare l'API RISC nel tuo progettoAPI Console . Devi utilizzare nella tua app lo stessoAPI Console progetto che utilizzi per accedere ai servizi Google, ad esempio Accedi con Google.
Per creare l'account di servizio:
Apri API Console Credentials page. Quando richiesto, scegli il progettoAPI Consoleche utilizzi per accedere ai servizi Google nella tua app.
Fai clic su Crea credenziali > Account di servizio.
Crea un nuovo account di servizio con il ruolo Amministratore configurazione RISC (
roles/riscconfigs.admin) seguendo queste istruzioni.Crea una chiave per l'account di servizio 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. Tieni questo file in un luogo sicuro, ma anche accessibile all'endpoint del destinatario dell'evento.
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 saranno necessari per convalidare i token evento di sicurezza, come descritto nella sezione successiva.
Per abilitare l'API RISC:
Apri la pagina dell'API RISC inAPI Console. 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 abiliti 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 Abilita solo se accetti i Termini RISC.
Crea un endpoint di ricezione di eventi
Per ricevere notifiche relative agli eventi di sicurezza da Google, crea un endpoint HTTPS che gestisce le richieste POST HTTPS. Dopo la registrazione di questo endpoint (vedi di seguito), Google inizierà a pubblicare nell'endpoint stringhe con firma crittografica chiamate token evento di sicurezza. I token di evento di sicurezza sono JWT firmati che contengono informazioni su un singolo evento relativo alla sicurezza.
Per ogni token evento di sicurezza che ricevi sul tuo endpoint, devi prima convalidare e decodificare il token, quindi gestire l'evento di sicurezza in base alle esigenze del tuo servizio. È essenziale convalidare il token evento prima della decodifica per evitare attacchi dannosi da parte di malintenzionati. Nelle sezioni seguenti vengono descritte queste attività:
1. Decodifica e convalida il token dell'evento di sicurezza
Poiché i token di evento di sicurezza sono un tipo specifico di JWT, puoi utilizzare qualsiasi libreria JWT, ad esempio quella elencata su jwt.io, per decodificarli e convalidarli. Qualunque sia la libreria che utilizzi, il codice di convalida del token deve:
- 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, disponibile 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 evento di sicurezza.
- Nel documento del certificato della chiave di firma di Google, recupera la chiave pubblica con l'ID della chiave che hai 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 di tua scelta, verifica quanto segue:
- Il token dell'evento di sicurezza viene firmato utilizzando la chiave pubblica che hai ottenuto nel passaggio precedente.
- La rivendicazione
auddel token è uno degli ID client delle tue app. - La rivendicazione
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, pertanto, non hanno scadenza.
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. Quindi, gestisci l'evento di sicurezza indicato dal token.
2. Gestire gli eventi di sicurezza
Una volta decodificato, un token dell'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 per il token (il tuo servizio). Hai verificato questi reclami nel
passaggio precedente.
L'attestazione jti è una stringa che identifica un singolo evento di sicurezza ed è
unica per il flusso. Puoi utilizzare questo identificatore per tenere traccia degli eventi di sicurezza ricevuti.
L'attestazione events contiene informazioni sull'evento di sicurezza rappresentato dal token. Questa rivendicazione è una mappatura da un identificatore di tipo di evento a una rivendicazione subject, che specifica l'utente interessato dall'evento e a eventuali dettagli aggiuntivi sull'evento che potrebbe essere disponibile.
La dichiarazione 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 più recente libreria Accedi con Google (Javascript, HTML), dalla libreria Accedi con Google legacy o da OpenID Connect. Quando subject_type della
rivendicazione è id_token_claims, potrebbe includere anche un campo email con l'indirizzo email
dell'utente.
Utilizza le informazioni nella dichiarazione events per intraprendere le azioni appropriate 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 di oggetto token contiene i seguenti campi:
token_type: è supportato solorefresh_token.token_identifier_alg: vedi la tabella di seguito per i possibili valori.token: consulta la tabella riportata di seguito.
| token_identifier_alg | token |
|---|---|
prefix |
I primi 16 caratteri del token. |
hash_base64_sha512_sha512 |
Il doppio hash del token che utilizza 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
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 riguarda Accedi con Google, interrompi le sessioni attualmente aperte. Inoltre, potresti suggerire all'utente di configurare un metodo di accesso alternativo. Suggerimento: se il token è per l'accesso ad altre API di Google, elimina tutti i token OAuth dell'utente che hai archiviato. |
|
https://schemas.openid.net/secevent/oauth/event-type/token-revoked |
Consulta la sezione Identificatori di token OAuth per gli identificatori di token |
Obbligatorio: se archivi il token di aggiornamento corrispondente, eliminalo e richiedi all'utente di dare 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 era
Suggerita: se il motivo per cui l'account è stato disattivato era
Suggerita: se non viene 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 |
Suggerito: 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-purged |
Suggerito: elimina l'account dell'utente o fornisci un metodo di accesso alternativo. | |
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required |
Suggerita: controlla l'eventuale presenza di attività sospette sul tuo servizio e adotta le misure appropriate. | |
https://schemas.openid.net/secevent/risc/event-type/verification |
state=state | Suggerita: registra la ricezione di un token di test. |
Eventi duplicati e persi
Protezione su più account tenterà di caricare nuovamente gli eventi che ritiene non siano stati pubblicati. Pertanto, a volte potresti ricevere lo stesso
evento più volte. Se questo potrebbe causare azioni ripetute che creano disagi agli utenti, valuta la possibilità di utilizzare la richiesta di jti (un identificatore univoco di un
evento) per eliminare gli eventi duplicati. Esistono strumenti esterni come Google Cloud Dataflow che possono aiutarti a eseguire la deduplicazione di Dataflow.
Tieni presente che gli eventi vengono inviati con tentativi limitati, 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 è necessario che nel progetto Google Cloud sia stata configurata una schermata per il consenso OAuth come prerequisito per i passaggi descritti di seguito.
1. Generare un token di autorizzazione
Per generare un token di autorizzazione per l'API RISC, crea un JWT con le seguenti attestazioni:
{
"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 account di servizio, che puoi trovare nel file JSON che hai scaricato quando hai creato la chiave dell'account di servizio.
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 usato 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 del flusso RISC
Ora che disponi di un token di autorizzazione, puoi usare l'API RISC per configurare il flusso di eventi di sicurezza del tuo progetto, inclusa la registrazione dell'endpoint del destinatario.
Per farlo, effettua una richiesta POST HTTPS a https://risc.googleapis.com/v1beta/stream:update, specificando l'endpoint del destinatario 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, il flusso di eventi è stato configurato correttamente e l'endpoint destinatario dovrebbe iniziare a ricevere token evento di sicurezza. La sezione successiva descrive come testare la configurazione del flusso e l'endpoint per verificare che tutto funzioni correttamente.
Ottieni e aggiorna la configurazione dei flussi attuale
Se, in futuro, vorrai modificare la configurazione del flusso, puoi farlo effettuando una richiesta GET autorizzata a https://risc.googleapis.com/v1beta/stream per ottenere la configurazione del flusso attuale, modificando il corpo della risposta e POSTICENDO la configurazione modificata su https://risc.googleapis.com/v1beta/stream:update come descritto sopra.
Interrompere e riprendere il flusso di eventi
Se devi interrompere il flusso di eventi da Google, effettua una richiesta POST autorizzata a https://risc.googleapis.com/v1beta/stream/status:update con { "status": "disabled" } nel corpo della richiesta. Quando il flusso è disattivato, Google non invia eventi al tuo endpoint e non esegue il buffering degli eventi di sicurezza quando si verificano. Per
riabilitare il flusso di eventi, POSTA { "status": "enabled" } allo stesso endpoint.
3. (Facoltativo) Testare la configurazione del flusso
Puoi verificare che la configurazione del flusso e l'endpoint del destinatario funzionino correttamente inviando un token di verifica tramite il flusso di eventi. Questo token può contenere una stringa univoca che puoi utilizzare per verificare che sia stato ricevuto sul tuo endpoint. Per utilizzare questo flusso, assicurati di iscriverti al https://schemas.openid.net/secevent/risc/event-type/verification tipo di evento quando registri il ricevitore.
Per richiedere un token di verifica, effettua una richiesta POST HTTPS autorizzata a
https://risc.googleapis.com/v1beta/stream:verify. Nel corpo della richiesta, specifica
una stringa di identificazione:
{
"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 ha esito positivo, il token di verifica verrà inviato all'endpoint che hai registrato. Quindi, ad esempio, se l'endpoint gestisce i token di verifica semplicemente registrandoli, puoi esaminare i log per verificare che il token sia 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 del flusso 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 non riuscita. Assicurati di aver allegato alla richiesta un token di autorizzazione e che il token sia valido e non sia scaduto. |
| 403 | L'endpoint di consegna deve essere un URL HTTPS. | L'endpoint di distribuzione (ovvero l'endpoint in cui prevedi che vengano consegnati gli eventi RISC) deve essere HTTPS. Non inviamo eventi RISC a URL HTTP. |
| 403 | La configurazione dei flussi 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 abilitato 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 a eseguire l'aggiornamento dopo un'ora. |
| 403 | Impossibile trovare il progetto. | Assicurati di utilizzare l'account di servizio corretto per il progetto corretto. È possibile che tu stia utilizzando un account di servizio associato a un progetto eliminato. Scopri come visualizzare tutti gli account di servizio associati a un progetto. |
| 403 | L'account di servizio richiede l'autorizzazione per accedere alla configurazione RISC | Vai al API Console del tuo progetto e assegna il ruolo "Amministratore configurazione RISC " (roles/riscconfigs.admin) all'account di servizio che effettua le chiamate al tuo progetto seguendo queste istruzioni.
|
| 403 | Le API di gestione dei flussi di dati devono essere chiamate solo da un account di servizio. | Scopri di più su come chiamare le API di Google con un account di servizio. |
| 403 | L'endpoint di pubblicazione non appartiene ad alcun dominio del progetto. | Ogni progetto ha un insieme di domini autorizzati. Se il tuo endpoint di distribuzione (ovvero l'endpoint in cui prevedi che vengano consegnati gli eventi RISC) non è ospitato su uno di questi, ti chiediamo di aggiungere il dominio dell'endpoint a questo insieme. |
| 403 | Per utilizzare questa API, nel tuo progetto deve essere configurato almeno un client OAuth. | 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 configurazioni 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 ulteriori informazioni, consulta il messaggio di errore dettagliato. |
Accedi agli ambiti dei token
Se decidi di utilizzare i token di accesso per l'autenticazione nell'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
O 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
O 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 relativa al riferimento al codice di errore. Se hai ancora domande, pubblicale su Stack Overflow con il tag #SecEvents.