Se la tua app consente agli utenti di accedere ai propri account con Google, puoi migliorare la sicurezza di questi utenti condivisi di account ascoltando e rispondendo Notifiche relative agli eventi di sicurezza fornite dal servizio Protezione su più account.
Queste notifiche ti avvisano di cambiamenti significativi agli Account Google dei tuoi utenti, il che può spesso avere implicazioni sulla sicurezza dei loro account la tua app. Ad esempio, se l'Account Google di un utente venisse compromesso, potrebbe potrebbero compromettere l'account dell'utente con la tua app via email il recupero dell'account o l'uso del servizio Single Sign-On.
Per aiutarti a mitigare il potenziale di rischio di questi eventi, Google ti invia di oggetti di servizio chiamati token di eventi di sicurezza. Questi token espongono poco solo il tipo di evento di sicurezza, quando si è verificato e dell'utente interessato, ma puoi utilizzarlo per acquisire l'azione appropriata in risposta. Ad esempio, se l'Account Google di un utente compromesso, potresti disattivare temporaneamente la funzionalità Accedi con Google per quell'utente Impedisce l'invio di email di recupero dell'account all'indirizzo Gmail dell'utente.
La Protezione su più account si basa sul standard RISC, sviluppato OpenID Foundation.
Panoramica
Per utilizzare la funzionalità Protezione su più account con la tua app o il tuo servizio, devi completare la le seguenti attività:
Configura il tuo progetto in API Console.
Crea un endpoint di ricezione degli eventi a cui Google invierà l'evento di sicurezza di token. Questo endpoint è responsabile della convalida dei token che riceve e rispondere agli eventi di sicurezza nel modo che preferisci.
Registra il tuo endpoint con Google per iniziare a ricevere i token degli eventi di sicurezza.
Prerequisito
Riceverai i token degli eventi di sicurezza solo per gli utenti Google che hanno concesso ai tuoi
l'autorizzazione del servizio ad accedere alle informazioni del profilo o agli indirizzi email. Tu
ottieni questa autorizzazione richiedendo gli ambiti profile
o email
. La nuova
Accedi con Google o la versione precedente
Gli SDK Accedi con Google richiedono questi ambiti per impostazione predefinita, ma
se non utilizzi le impostazioni predefinite o se accedi all'ambiente OpenID di Google
Connetti l'endpoint direttamente, assicurati
richiedi 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 servizio e abilitare l'API RISC nel tuo API Console . Devi usare lo stesso API Console progetto a cui accedi per accedere Servizi Google, come Accedi con Google, nella tua app.
Per creare l'account di servizio:
Apri l'app API Console Credentials page. Quando richiesto, scegli API Console progetto che utilizzi per accedere ai servizi Google nella tua app.
Fai clic su Crea credenziali > Account di servizio.
Creare 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 la chiave JSON digita e fai clic su Crea. Quando la chiave viene creata, scaricherai un file JSON contenente il tuo account di servizio e credenziali. Conserva il file in un luogo sicuro, ma accessibile anche al tuo dell'endpoint del destinatario di eventi.
Mentre sei nella pagina Credenziali del tuo progetto, prendi nota anche del client ID che utilizzi per Accedi con Google o Accedi con Google (legacy). Di solito, hai un ID cliente per ogni alla piattaforma supportata. Ti serviranno questi ID client per convalidare l'evento di sicurezza come descritto nella sezione successiva.
Per abilitare l'API RISC:
Apri la pagina dell'API RISC nella sezione API Console. Assicurati che il progetto che utilizzi per accedere ai servizi Google è ancora selezionata.
Leggi i termini RISC e assicurati di aver compreso i requisiti.
Se abiliti l'API per un progetto di proprietà di un'organizzazione, assicurati si dispone dell'autorizzazione per vincolare la propria organizzazione ai Termini RISC.
Fai clic su Abilita solo se accetti i Termini RISC.
Crea un endpoint destinatario di eventi
Per ricevere notifiche relative agli eventi di sicurezza da Google, crea un endpoint HTTPS che gestisce le richieste POST HTTPS. Dopo aver registrato questo endpoint (vedi sotto), Google inizierà a pubblicare stringhe firmate tramite crittografia chiamate "evento di sicurezza" all'endpoint. I token degli eventi di sicurezza sono JWT firmati che contengono informazioni su un singolo evento relativo alla sicurezza.
Per ogni token dell'evento di sicurezza che ricevi nell'endpoint, devi prima convalidare e decodificare il token, quindi gestire l'evento di sicurezza in modo appropriato per il tuo completamente gestito di Google Cloud. È essenziale convalidare il token dell'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 degli eventi di sicurezza sono un tipo specifico di JWT, puoi utilizzare qualsiasi libreria JWT, ad esempio quella elencata su jwt.io, per decodificare e e convalidarle. Qualunque sia la libreria che utilizzi, il codice di convalida del token deve seguenti:
- Recupera l'identificatore emittente della Protezione su più account (
issuer
) e la chiave di firma l'URI del certificato (jwks_uri
) del documento di configurazione RISC di Google, che puoi trovare all'indirizzohttps://accounts.google.com/.well-known/risc-configuration
. - Utilizzando la libreria JWT di tua scelta, 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 dell'ID chiave ottenuto nel passaggio precedente. Se il documento non contiene una chiave e l'ID che stai cercando, è probabile che il token dell'evento di sicurezza sia non 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 ricevuto nel passaggio precedente.
- La rivendicazione
aud
del token è una delle tue app gli ID cliente. - La rivendicazione
iss
del token corrisponde all'identificatore dell'emittente che hai ricevuto il 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, come tali, 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, restituisce 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 ha il seguente aspetto:
{
"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 dichiarazioni iss
e aud
indicano l'emittente del token (Google) e
destinatario previsto dal token (il tuo servizio). Hai verificato queste rivendicazioni nel
passaggio precedente.
L'attestazione jti
è una stringa che identifica un singolo evento di sicurezza e
univoci per lo stream. Puoi utilizzare questo identificatore per monitorare quali eventi di sicurezza
che hai ricevuto.
L'attestazione events
contiene informazioni sull'evento di sicurezza associato al token
che rappresenta. Questa dichiarazione è una mappatura da un identificatore di tipo di evento a un subject
che specifica l'utente interessato dall'evento in questione, oltre a qualsiasi
i dettagli dell'evento che potrebbero essere disponibili.
La dichiarazione subject
identifica un determinato utente con il nome utente univoco
ID account (sub
). Questo ID Account Google è lo stesso identificatore (sub
) contenuto
nei token ID JWT emessi dalla nuova versione di Accedi con Google (JavaScript
, HTML), la libreria Accedi con Google precedente o
OpenID Connect. Quando il valore subject_type
del
la dichiarazione è id_token_claims
, potrebbe includere anche un campo email
con
all'indirizzo email dell'utente.
Utilizza le informazioni nella dichiarazione events
per adottare le misure appropriate per
tipo di evento specifico
nell'account dell'utente specificato.
Identificatori di token OAuth
Per gli eventi OAuth relativi a singoli token, il tipo di identificatore oggetto token contiene i seguenti campi:
token_type
: è supportato solorefresh_token
.token_identifier_alg
: consulta la tabella seguente per i possibili valori.token
: consulta la tabella seguente.
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 su questi possibili valori per garantire una corrispondenza rapida quando l'evento viene ricevuto.
Tipi di eventi supportati
La funzionalità 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 l'attuale sessioni aperte. | |
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked |
Obbligatorio: se il token riguarda Accedi con Google, termina sessioni attualmente aperte. Inoltre, potresti suggerire all'utente di configurare un metodo di accesso alternativo. Suggerito: se il token riguarda l'accesso ad altre API di Google, elimina qualsiasi 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 identificatori token |
Obbligatorio: se memorizzi il token di aggiornamento corrispondente, eliminalo e chiedere 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 della disattivazione dell'account è stato
Suggerita: se il motivo della disattivazione dell'account era
Suggerita: se non è stato specificato alcun motivo, disattiva Accedi con Google per utente e disattiva il recupero dell'account utilizzando l'indirizzo email associato a L'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 |
Suggerita: riattiva l'opzione Accedi con Google per l'utente e riattivala. recupero dell'account con l'indirizzo email dell'Account Google dell'utente. | |
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required |
Suggerite: cerca attività sospette nel servizio e rileva l'azione adeguata. | |
https://schemas.openid.net/secevent/risc/event-type/verification |
state=state | Suggerito: registra la ricezione di un token di test. |
Eventi duplicati e persi
Protezione su più account tenterà di pubblicare nuovamente gli eventi che ritiene abbiano
non sono stati consegnati. Pertanto, a volte potresti ricevere lo stesso evento
più volte. Se ciò causasse azioni ripetute che arrecano disagi
agli utenti, puoi utilizzare la dichiarazione jti
(che è un identificatore univoco per
per rimuovere il doppio degli eventi. Esistono strumenti esterni come Google Cloud
Dataflow che può aiutarti a eseguire
il flusso di dati di deduplicazione.
Tieni presente che gli eventi vengono consegnati con un numero limitato di nuovi tentativi, quindi se il ricevitore non è disponibile per un periodo di tempo prolungato potresti perdere definitivamente alcuni eventi.
Registra il destinatario
Per iniziare a ricevere eventi di sicurezza, registra l'endpoint destinatario utilizzando API RISC. Le chiamate all'API RISC devono essere accompagnate da un token di autorizzazione.
Poiché riceverai gli eventi di sicurezza solo per gli utenti della tua app, devi aver configurato una schermata per il consenso OAuth nel tuo progetto Google Cloud come prerequisito per i passaggi descritti di seguito.
1. Genera un token di autorizzazione
Per generare un token di autorizzazione per l'API RISC, crea un token 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 dell'account di servizio, che puoi trovare nel File JSON scaricato durante la creazione della chiave dell'account di servizio.
Ad esempio:
Java
Utilizzando java-jwt e 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 stream RISC
Ora che disponi di un token di autorizzazione, puoi utilizzare l'API RISC per configurare il flusso di eventi di sicurezza del tuo progetto, inclusa la registrazione del destinatario endpoint.
A questo scopo, effettua una richiesta POST HTTPS a https://risc.googleapis.com/v1beta/stream:update
,
specificando l'endpoint del destinatario e i tipi di sicurezza
eventi 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 ricevente dovrebbe iniziare a ricevere i token degli eventi di sicurezza. La la prossima sezione descrive come testare la configurazione e l'endpoint dello stream per verificare che tutto funzioni correttamente.
Scarica e aggiorna la configurazione attuale dello stream
Se in futuro vorrai modificare la configurazione dello stream, potrai farlo
Pertanto, inviando una richiesta GET autorizzata a https://risc.googleapis.com/v1beta/stream
per ottenere
la configurazione del flusso corrente, modificando il corpo della risposta e quindi
configurazione modificata tornando a https://risc.googleapis.com/v1beta/stream:update
come descritto sopra.
Interrompi e riprendi il flusso di eventi.
Se devi interrompere lo stream di eventi da Google, crea un POST autorizzato
richiesta 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 il buffering degli eventi di sicurezza quando si verificano. A
riattiva il flusso di eventi, POST { "status": "enabled" }
sullo stesso endpoint.
3. (Facoltativo) Testare la configurazione dello stream
Puoi verificare che la configurazione dello stream e l'endpoint di ricezione funzionino correttamente correttamente inviando un token di verifica tramite lo stream di eventi. Questo token può contenere una stringa univoca che puoi utilizzare per verificare che il che sia stato ricevuto sul tuo endpoint. Per utilizzare questo flusso, assicurati di iscriviti a https://schemas.openid.net/secevent/risc/event-type/verification tipo di evento durante la registrazione del 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 alcune
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 ha esito positivo, il token di verifica verrà inviato all'endpoint registrato. Quindi, ad esempio, se il tuo endpoint gestisce i token di verifica registrandoli, puoi esaminare i log per verificare che il token 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ò esserlo analizzato. Includi $fieldname nella richiesta. |
401 | Non autorizzato. | Autorizzazione non riuscita. Assicurati di aver allegato un token di autorizzazione con la richiesta e che il token sia valido. e non sia scaduto. |
403 | L'endpoint di pubblicazione deve essere un URL HTTPS. | L'endpoint di pubblicazione (ossia l'endpoint a cui ti aspetti che gli eventi RISC inviati a) devono essere HTTPS. Non inviamo eventi RISC a URL HTTP. |
403 | La configurazione esistente dello stream non dispone di una pubblicazione conforme alle specifiche per RISC. | Il tuo progetto Google Cloud deve avere già una configurazione RISC. Se stai utilizzando Firebase e hai attivato l'opzione Accedi con Google, Firebase sarà la gestione del RISC per il tuo progetto; non potrai creare un modello configurazione. 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 l'account di servizio corretto progetto. È possibile che tu stia utilizzando un account di servizio associato a un account di progetto. Impara come visualizzare tutti gli account di servizio associati a un progetto. |
403 | L'account di servizio richiede l'autorizzazione per accedere al RISC configurazione | Vai alla sezione API Console e
Assegna il ruolo "Amministratore configurazione RISC" ruolo
(roles/riscconfigs.admin )
all'account di servizio che effettua le chiamate al progetto
persone che seguo
queste istruzioni.
|
403 | Le API di gestione dei flussi devono essere chiamate solo da un account di servizio. | Di seguito puoi trovare ulteriori informazioni 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 domini autorizzati. Se l'endpoint di pubblicazione (ovvero l'endpoint a cui ti aspetti che gli eventi RISC ai quali non è ospitata) non sia ospitata su uno di questi, ti chiediamo di aggiungere il dominio dell'endpoint in quel set. |
403 | Per utilizzare questa API, nel 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 progetto non ha OAuth probabile che RISC non vi sia utile. Scopri di più sull'utilizzo di OAuth da parte di Google per le nostre API. |
403 |
Stato non supportato. Stato non valido. |
Supportiamo solo gli stati dello stream "enabled " e
"disabled " al momento. |
404 |
Il progetto non ha una configurazione RISC. Il progetto non ha una configurazione RISC esistente e non può 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. |
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 relativa al riferimento del codice di errore. Se continui per eventuali domande, pubblicale su Stack Overflow con #SecEvents del tag.