Proteggi gli account utente con la protezione tra account

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 di eventi di sicurezza fornite dal servizio di protezione tra account.

Queste notifiche ti avvisano di modifiche importanti agli Account Google dei tuoi utenti, che spesso possono avere anche implicazioni sulla sicurezza dei loro account con la tua app. Ad esempio, se l'account Google di un utente viene dirottato, potrebbe potenzialmente portare a una compromissione dell'account dell'utente con la tua app tramite il recupero dell'account e-mail o l'uso del Single Sign-On.

Per aiutarti a ridurre il rischio potenziale di tali eventi, Google invia i tuoi oggetti di servizio chiamati token di eventi di sicurezza. Questi token espongono pochissime informazioni, solo il tipo di evento di sicurezza e quando si è verificato, e l'identificatore dell'utente interessato, ma è possibile utilizzarli per intraprendere l'azione appropriata in risposta. Ad esempio, se l'account Google di un utente è stato compromesso, è possibile 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 cross-account si basa sullo standard RISC , sviluppato presso la OpenID Foundation.

Panoramica

Per utilizzare la protezione tra account con la tua app o servizio, devi completare le seguenti attività:

  1. Configura il tuo progetto in API Console.

  2. Crea 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.

  3. Registra il tuo endpoint con Google per iniziare a ricevere i token degli eventi di sicurezza.

Prerequisito

Ricevi i token degli eventi di sicurezza solo per gli utenti Google che hanno concesso al tuo servizio l'autorizzazione ad accedere alle informazioni del loro profilo o agli indirizzi email. Ottieni questa autorizzazione richiedendo il profile o gli ambiti di email . Il più recente Accedi con Google o gli SDK di accesso di Google legacy 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.

Imposta un progetto in API Console

Prima di poter iniziare a ricevere i token degli eventi di sicurezza, devi creare un account di servizio e abilitare l'API RISC nel tuo progettoAPI Console . Devi utilizzare lo stesso progettoAPI Console che utilizzi per accedere ai servizi Google, come Google Sign-in, nella tua app.

Per creare l'account di servizio:

  1. Aprire API ConsoleCredentials page . Quando richiesto, scegli il progettoAPI Consoleche utilizzi per accedere ai servizi Google nella tua app.

  2. Fare clic su Crea credenziali > Account di servizio .

  3. Crea un nuovo account di servizio con il ruolo Editor.

  4. Crea una chiave per il tuo account di servizio appena creato. Scegli il tipo di chiave JSON e quindi fai clic su Crea . Quando la chiave viene creata, scaricherai un file JSON che contiene le credenziali del tuo account di servizio. Conserva questo file in un luogo sicuro, ma anche accessibile all'endpoint del ricevitore di eventi.

Mentre sei nella pagina Credenziali del tuo progetto, prendi nota anche degli ID cliente che utilizzi per Accedi con Google o Accedi con Google (legacy). In genere, hai un ID client per ogni piattaforma supportata. Avrai bisogno di questi ID client per convalidare i token degli eventi di sicurezza, come descritto nella sezione successiva.

Per abilitare l'API RISC:

  1. Aprire la pagina dell'API RISC inAPI Console. Assicurati che il progetto che utilizzi per accedere ai servizi Google sia ancora selezionato.

  2. 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 essere autorizzato a vincolare la tua organizzazione ai Termini RISC.

  3. Fare clic su Abilita solo se acconsenti ai Termini RISC.

Crea un endpoint del ricevitore di eventi

Per ricevere notifiche di eventi di sicurezza da Google, crei un endpoint HTTPS che gestisce le richieste HTTPS POST. Dopo aver registrato questo endpoint (vedi sotto), Google inizierà a pubblicare stringhe firmate crittograficamente chiamate token di eventi di sicurezza sull'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 sull'endpoint, prima convalida e decodifica il token, quindi gestisci l'evento di sicurezza come appropriato per il 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. Decodificare e convalidare il token dell'evento di sicurezza

Poiché i token degli eventi di sicurezza sono un tipo specifico di JWT, puoi utilizzare qualsiasi libreria JWT, come quella elencata su jwt.io , per decodificarli e convalidarli. Qualunque sia la libreria che utilizzi, il codice di convalida del token deve eseguire le seguenti operazioni:

  1. Ottieni l'identificatore issuer di protezione incrociata ( Issuer ) e l'URI del certificato della chiave di firma ( jwks_uri ) dal documento di configurazione RISC di Google, che puoi trovare all'indirizzo https://accounts.google.com/.well-known/risc-configuration .
  2. Utilizzando la libreria JWT di tua scelta, ottieni l'ID della chiave di firma dall'intestazione del token dell'evento di sicurezza.
  3. Dal documento del certificato della chiave di firma di Google, ottieni la chiave pubblica con l'ID 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 il tuo endpoint dovrebbe restituire l'errore HTTP 400.
  4. Utilizzando la libreria JWT di tua scelta, verifica quanto segue:
    • Il token dell'evento di sicurezza viene firmato utilizzando la chiave pubblica ottenuta nel passaggio precedente.
    • L' aud del token è uno degli ID client delle tue app.
    • L' iss del token corrisponde all'identificatore dell'emittente che hai 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.

Per esempio:

Giava

Usando 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;
}

Pitone

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 del token (il tuo servizio). Hai verificato queste affermazioni nel passaggio precedente.

L' jti è una stringa che identifica un singolo evento di sicurezza ed è univoca per il flusso. Puoi utilizzare questo identificatore per tenere traccia di quali eventi di sicurezza hai ricevuto.

L'attestazione 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 particolare 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 ( Javascript , HTML ) più recente, dalla libreria di accesso Google legacy o da OpenID Connect . Quando il subject_type dell'attestazione è id_token_claims , potrebbe includere anche un campo email con l'indirizzo e-mail dell'utente.

Utilizzare le informazioni nell'attestazione di events per intraprendere l'azione appropriata per il tipo di evento nell'account dell'utente specificato.

Tipi di eventi supportati

La protezione tra 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 : proteggere nuovamente l'account dell'utente terminando le sessioni attualmente aperte.
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

Richiesto : se il token è per l'accesso con Google, termina le sessioni attualmente aperte. Inoltre, potresti suggerire all'utente di configurare un metodo di accesso alternativo.

Consigliato : se il token è per l'accesso ad altre API di Google, elimina tutti i token OAuth dell'utente che hai memorizzato.

https://schemas.openid.net/secevent/risc/event-type/account-disabled reason=hijacking ,
reason=bulk-account

Richiesto : se il motivo per cui l'account è stato disabilitato era il hijacking , riproteggi l'account dell'utente terminando le sessioni attualmente aperte.

Consigliato : se il motivo per cui l'account è stato disabilitato era bulk-account , analizza l'attività dell'utente sul tuo servizio e determina le azioni di follow-up appropriate.

Suggerito : se non è stato fornito alcun motivo, disabilitare l'accesso con Google per l'utente e disabilitare il ripristino dell'account utilizzando l'indirizzo e-mail 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 Consigliato : riattiva l'accesso 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 : eliminare l'account dell'utente o fornire loro un metodo di accesso alternativo.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Suggerito : cerca le attività sospette sul tuo servizio e prendi le misure appropriate.
https://schemas.openid.net/secevent/risc/event-type/verification stato = state Suggerito : registra che è stato ricevuto un token di prova.

Eventi duplicati e persi

La protezione cross-account tenterà di inviare nuovamente gli eventi che ritiene non siano stati consegnati. Pertanto, a volte potresti ricevere lo stesso evento più volte. Se ciò potrebbe causare azioni ripetute che infastidiscono i tuoi utenti, prendi in considerazione l'utilizzo jti (che è un identificatore univoco per 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 consegnati con tentativi limitati, quindi se il ricevitore è inattivo per un periodo di tempo prolungato potresti perdere permanentemente alcuni eventi.

Registra il tuo ricevitore

Per iniziare a ricevere eventi di sicurezza, registra l'endpoint 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 di consenso OAuth configurata nel tuo progetto GCP 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 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.

Per esempio:

Giava

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;
}

Pitone

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. Chiamare l'API di configurazione del flusso 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 dell'endpoint del ricevitore.

Per fare ciò, fai una richiesta HTTPS POST a https://risc.googleapis.com/v1beta/stream:update , specificando l'endpoint del tuo 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
  ]
}

Per esempio:

Giava

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);

Pitone

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 del ricevitore dovrebbe iniziare a ricevere i token degli eventi di sicurezza. La sezione successiva descrive come testare la configurazione del flusso e l'endpoint per verificare che tutto funzioni correttamente insieme.

Ottieni e aggiorna la tua attuale configurazione del flusso

Se, in futuro, desideri modificare la configurazione del tuo stream, puoi farlo facendo 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 ripubblicare la configurazione modificata su https://risc.googleapis.com/v1beta/stream:update come descritto sopra.

Interrompi e riprendi il flusso di eventi

Se hai bisogno di interrompere il flusso di eventi da Google, fai 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 gli eventi di sicurezza nel buffer quando si verificano. Per riattivare il flusso di eventi, POST { "status": "enabled" } sullo stesso endpoint.

3. Facoltativo: verifica la configurazione del flusso

Puoi verificare che la configurazione del flusso e l'endpoint del ricevitore 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 il token sia stato ricevuto nell'endpoint.

Per richiedere un token di verifica, effettua una richiesta POST HTTPS autorizzata a https://risc.googleapis.com/v1beta/stream:verify . Nel corpo della richiesta, specificare una stringa identificativa:

{
  "state": "ANYTHING"
}

Per esempio:

Giava

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);

Pitone

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 il tuo endpoint gestisce i token di verifica semplicemente registrandoli, puoi esaminare i tuoi log per confermare che il token è stato ricevuto.

Riferimento del codice di errore

I seguenti errori possono essere restituiti dall'API RISC:

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. Si prega di includere $fieldname nella richiesta.
401 Non autorizzato. Autorizzazione fallita. Assicurati di aver allegato un token di autorizzazione alla richiesta e che il token sia valido e non sia scaduto.
403 L'endpoint di consegna deve essere un URL HTTPS. Il tuo endpoint di consegna (ovvero l'endpoint a cui ti aspetti che vengano consegnati gli eventi RISC) deve essere HTTPS. Non inviamo eventi RISC a URL HTTP.
403 La configurazione del flusso esistente non ha un metodo di consegna conforme alle specifiche per RISC. Il tuo progetto Google Cloud deve già avere una configurazione RISC. Se stai utilizzando Firebase e hai abilitato l'accesso con Google, Firebase gestirà il RISC per il tuo progetto; non sarai in grado di creare una configurazione personalizzata. Se non stai utilizzando Google Sign-In per il tuo progetto Firebase, disabilitalo e riprova ad aggiornare dopo un'ora.
403 Impossibile trovare il progetto. Assicurati di utilizzare l'account di servizio corretto per il progetto corretto. Potresti utilizzare 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 deve disporre delle autorizzazioni di editor nel progetto. Vai alla console Google Cloud Platform del tuo progetto e concedi all'account di servizio che sta effettuando l'autorizzazione al tuo progetto come editore/proprietario delle chiamate seguendo queste istruzioni .
403 Le API di gestione del flusso devono essere chiamate solo da un account di servizio. Di seguito sono riportate ulteriori informazioni su come chiamare le API di Google con un account di servizio .
403 L'endpoint di consegna non appartiene a nessuno dei domini del tuo progetto. Ogni progetto ha un insieme di domini autorizzati. Se il tuo endpoint di consegna (ovvero l'endpoint a cui ti aspetti che vengano consegnati gli eventi RISC) non è ospitato su uno di essi, ti chiediamo di aggiungere il dominio dell'endpoint a quel set.
403 Per utilizzare questa API, il tuo progetto deve avere almeno un client OAuth configurato. RISC funziona solo se crei un'app che supporta Google Sign In . Questa connessione richiede un client OAuth. Se il tuo progetto non ha client OAuth, è probabile che RISC non ti sarà utile. Ulteriori informazioni sull'utilizzo da parte di Google di OAuth per le nostre API .
403

Stato non supportato.

Stato non valido.

Supportiamo solo gli stati di streaming " enabled " e " disabled " in questo momento.
404

Il progetto non ha una configurazione RISC.

Il progetto non ha una configurazione RISC esistente, non può aggiornare lo stato.

Chiama l'endpoint https://risc.googleapis.com/v1beta/stream:update per creare una nuova configurazione del flusso.
4XX/5XX Impossibile aggiornare lo stato. Controllare il messaggio di errore dettagliato per ulteriori informazioni.

Accedere agli ambiti dei token

Se decidi di utilizzare i token di accesso per l'autenticazione all'API RISC, questi sono gli ambiti che la tua applicazione deve richiedere:

Punto finale Scopo
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

Ho bisogno di aiuto?

Innanzitutto, controlla la nostra sezione di riferimento del codice di errore . Se hai ancora domande, pubblicale su Stack Overflow con il tag #SecEvents .