Proteggere gli account utente con la Protezione su più account

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Se la tua app consente agli utenti di accedere ai loro account utilizzando Google, puoi migliorare la sicurezza di questi account condivisi ascoltando le notifiche degli eventi di sicurezza fornite dal servizio Protezione su più account e rispondendo a queste.

Queste notifiche ti avvisano di importanti modifiche agli Account Google degli utenti, che spesso possono anche avere implicazioni per la sicurezza dei loro account con la tua app. Ad esempio, se l'Account Google di un utente è stato compromesso, potrebbe potenzialmente compromettere l'account dell'utente con la tua app tramite il recupero dell'account email o l'utilizzo del Single Sign-On.

Per aiutarti a ridurre il potenziale di rischio di tali eventi, Google invia gli oggetti del servizio chiamati token evento di sicurezza. Questi token presentano pochissime informazioni (solo il tipo di evento di sicurezza e quando si è verificato, nonché l'identificatore dell'utente interessato), ma possono essere utilizzati per eseguire azioni appropriate in risposta. Ad esempio, se l'Account Google di un utente è stato compromesso, puoi disattivare temporaneamente la funzionalità 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 la Fondazione OpenID.

Panoramica

Per utilizzare la protezione su più account con la tua app o il tuo servizio, devi completare le seguenti attività:

  1. Configura il tuo progetto nel API Console.

  2. Creare un endpoint per il ricevitore di eventi, a cui Google invierà i token degli eventi di sicurezza. Questo endpoint è responsabile della convalida dei token ricevuti e della risposta agli eventi di sicurezza nel modo che preferisci.

  3. Registra il tuo endpoint su Google per iniziare a ricevere token di sicurezza.

Prerequisito

Ricevi i token evento di sicurezza solo per gli utenti Google che hanno concesso al tuo servizio l'autorizzazione ad accedere alle informazioni del profilo o agli indirizzi email. Per ottenere questa autorizzazione, richiedi gli ambiti profile o email. I nuovi SDK Accedi con Google o legacy di Accedi con Google richiedono questi ambiti per impostazione predefinita, ma se non utilizzi le impostazioni predefinite o se accedi direttamente all'endpoint OpenConnect di Google, assicurati di richiedere almeno uno di questi ambiti.

Configura un progetto in API Console

Prima di poter iniziare a ricevere i token evento di sicurezza, devi creare un account di servizio e abilitare l'API RISC nel tuo progettoAPI Console . Devi utilizzare lo stessoAPI Console progetto che utilizzi per accedere ai servizi Google, ad esempio Accedi con Google, nella tua app.

Per creare l'account di servizio:

  1. Apri la API Console Credentials page. Quando richiesto, scegli il progettoAPI Consoleda utilizzare per accedere ai servizi Google nella tua app.

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

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

  4. Crea una chiave per l'account di servizio appena creato. Scegli il tipo di chiave JSON e fai clic su Crea. Quando la chiave viene creata, scaricarai un file JSON contenente le credenziali dell'account di servizio. Conserva questo file in un luogo sicuro, ma anche accessibile all'endpoint del destinatario dell'evento.

Quando ti trovi nella pagina Credenziali del tuo progetto, prendi anche nota degli ID client che utilizzi per Accedi con Google o per Accedi con Google (precedente). In genere, hai un ID client per ogni piattaforma che supporti. Questi ID client sono necessari per convalidare i token degli eventi di sicurezza, come descritto nella sezione seguente.

Per abilitare l'API RISC:

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

  2. Leggi i Termini di RISC e assicurati di comprendere i requisiti.

    Se abiliti l'API per un progetto di proprietà di un'organizzazione, assicurati di disporre dell'autorizzazione per vincolare la tua organizzazione ai termini di RISC.

  3. Fai clic su Attiva solo se accetti i Termini di RISC.

Crea un endpoint del destinatario degli eventi

Per ricevere notifiche relative agli 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 nell'endpoint stringhe firmate con crittografia chiamate token di evento di sicurezza. I token evento di sicurezza sono JWT firmati che contengono informazioni su un singolo evento relativo alla sicurezza.

Per ogni token dell'evento di sicurezza che ricevi sul tuo endpoint, devi prima convalidare e decodificare il token, quindi gestire l'evento di sicurezza in base al tuo servizio. È essenziale convalidare il token dell'evento prima di procedere alla decodifica per evitare attacchi dannosi da parte di malintenzionati. Queste attività sono descritte nelle sezioni seguenti:

1. Decodificare e convalidare il token di sicurezza

Poiché i token 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. Indipendentemente dalla libreria utilizzata, il codice di convalida del token deve:

  1. Recupera l'identificatore dell'emittente di Protezione su più account (issuer) e l'URI del certificato della chiave di firma (jwks_uri) del documento di configurazione RISC di Google, disponibile all'indirizzo https://accounts.google.com/.well-known/risc-configuration.
  2. Utilizzando la libreria JWT che preferisci, recupera l'ID della chiave di firma nell'intestazione del token dell'evento di sicurezza.
  3. Dal documento del certificato della chiave di firma di Google, recupera 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 restituisca un 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 che hai ottenuto nel passaggio precedente.
    • La rivendicazione aud del token è uno dei tuoi ID client delle tue app.
    • La rivendicazione iss del token corrisponde all'identificatore emittente che hai ricevuto nel documento di rilevamento di RISC. Tieni presente che non devi verificare la scadenza del token (exp) perché i token evento della 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. Quindi, gestisci l'evento di sicurezza indicato dal token.

2. Gestire gli eventi di sicurezza

Quando viene decodificato, un token 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 rivendicazioni iss e aud indicano l'emittente del token (Google) e del destinatario previsto del token (il tuo servizio). Hai verificato queste rivendicazioni nel passaggio precedente.

La rivendicazione jti è una stringa che identifica un singolo evento di sicurezza ed è univoca per il flusso. Puoi utilizzare questo identificatore per monitorare quali eventi di sicurezza hai ricevuto.

La rivendicazione events contiene informazioni sull'evento di sicurezza rappresentato dal token. Questa rivendicazione è una mappatura da un identificatore del tipo di evento a una rivendicazione subject, che specifica l'utente interessato da questo evento, nonché a eventuali altri dettagli sull'evento che potrebbero essere disponibili.

La rivendicazione subject identifica un determinato utente con l'ID Account Google univoco dell'utente (sub). Questo ID dell'Account Google è lo stesso identificatore (sub) contenuto nei token ID JWT emessi dalla libreria Accedi con Google (JavaScript , HTML) più recente, dalla libreria precedente di Accedi con Google o 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 rivendicazione events per intraprendere le azioni appropriate per il tipo di evento nell'account utente specificato.

Identificatori di token OAuth

Per gli eventi OAuth su singoli token, il tipo di identificatore oggetto token contiene i seguenti campi:

  • token_type: è supportato solo refresh_token.

  • token_identifier_alg: consulta la tabella di seguito per i possibili valori.

  • token: vedi la tabella seguente.

token_identifier_alg token
prefix I primi 16 caratteri del token.
hash_base64_sha512_sha512 Il doppio hash del token utilizzando l'algoritmo SHA-512.

Se esegui l'integrazione con questi eventi, ti consigliamo di indicizzare i token in base a questi valori possibili 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 di nuovo l'account dell'utente terminando le sessioni attualmente aperte.
https://schemas.openid.net/secevent/oauth/event-type/tokens-revoked

Obbligatorio: se il token è associato a Accedi con Google, termina le sessioni attualmente aperte. Inoltre, puoi suggerire all'utente di configurare un metodo di accesso alternativo.

Suggerito: se il token serve per accedere ad altre API di Google, elimina uno qualsiasi dei token OAuth dell'utente che hai archiviato.

https://schemas.openid.net/secevent/oauth/event-type/token-revoked Consulta la sezione Identificatori token OAuth per informazioni sugli identificatori token

Obbligatorio: se memorizzi il token di aggiornamento corrispondente, eliminalo e richiedi all'utente di dare nuovamente il consenso la prossima volta che è 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 era hijacking, proteggi di nuovo l'account dell'utente terminando le sessioni attualmente aperte.

Suggerito: se il motivo della disattivazione dell'account era bulk-account, analizza l'attività dell'utente sul servizio e determina le azioni di follow-up appropriate.

Suggerito: se non è stato fornito alcun motivo, disattiva l'opzione 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 l'opzione 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 forniscigli un metodo di accesso alternativo.
https://schemas.openid.net/secevent/risc/event-type/account-credential-change-required Suggerita: cerca le attività sospette nel servizio e intraprendi le azioni opportune.
https://schemas.openid.net/secevent/risc/event-type/verification stato=state Suggerito: registra la ricezione di un token di test.

Eventi duplicati e persi

La protezione su più account tenterà di caricare di nuovo gli eventi che ritiene non siano stati pubblicati. Di conseguenza, a volte potresti ricevere lo stesso evento più volte. Se questo può causare ripetute azioni che infastidiscono gli utenti, puoi 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 lavoro di deduplicazione.

Tieni presente che gli eventi vengono pubblicati con un numero limitato di nuovi tentativi, quindi se il ricevitore rimane inattivo per un periodo di tempo prolungato, potresti perdere definitivamente alcuni eventi.

Registra il tuo destinatario

Per iniziare a ricevere eventi di sicurezza, registra l'endpoint del destinatario utilizzando l'API RISC. Le chiamate all'API RISC devono essere accompagnate da un token di autorizzazione.

Riceverai gli eventi di sicurezza solo per gli utenti della tua app, quindi devi avere una schermata di consenso OAuth configurata nel 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 dichiarazioni:

{
  "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, disponibile nel file JSON scaricato al momento della creazione della 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 utilizzato per effettuare chiamate API RISC per un'ora. Alla scadenza del token, generane uno nuovo per continuare a effettuare chiamate API RISC.

2. Chiama l'API RISC stream configuration

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 di ricezione.

Per farlo, invia 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, lo stream di eventi è stato configurato correttamente e l'endpoint di ricezione dovrebbe iniziare a ricevere token di sicurezza. La sezione successiva descrive come testare la configurazione dei tuoi stream e l'endpoint per verificare che tutto funzioni correttamente insieme.

Recupera e aggiorna la configurazione dello stream corrente

Se in futuro vorrai modificare la configurazione dello stream, potrai effettuare una richiesta GET autorizzata a https://risc.googleapis.com/v1beta/stream per ottenere la configurazione dello stream corrente, modificare il corpo della risposta e POSTARE la configurazione modificata a https://risc.googleapis.com/v1beta/stream:update come descritto sopra.

Interrompere e riprendere lo stream di eventi

Se devi interrompere lo stream 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 lo stream è disattivato, Google non invia eventi al tuo endpoint e non bufferizza gli eventi di sicurezza quando si verificano. Per riattivare lo stream di eventi, POST { "status": "enabled" } nello stesso endpoint.

3. Facoltativo: testa la configurazione dello stream

Puoi verificare che la configurazione dello stream e l'endpoint del ricevitore funzionino 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 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, 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 registrato. Quindi, ad esempio, se il tuo endpoint gestisce i token di verifica semplicemente registrandoli, puoi esaminare i log per confermare che sono stati ricevuti.

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.
Messaggio di errore Non autorizzato. Autorizzazione non riuscita. Assicurati di aver allegato un token di autorizzazione con la richiesta e che il token sia valido e che non sia scaduto.
Messaggio di errore L'endpoint di pubblicazione deve essere un URL HTTPS. Il tuo endpoint di distribuzione (ovvero l'endpoint in cui prevedi che gli eventi RISC vengano distribuiti) deve essere di tipo HTTPS. Non inviamo eventi RISC agli URL HTTP.
Messaggio di errore 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 l'opzione Accedi con Google è abilitata, Firebase gestirà RISC per il tuo progetto; non potrai creare una configurazione personalizzata. Se non utilizzi Accedi con Google per il progetto Firebase, disattivalo e riprova a eseguire l'aggiornamento dopo un'ora.
Messaggio di errore Impossibile trovare il progetto. Assicurati di utilizzare l'account di servizio corretto per il progetto corretto. Potresti aver utilizzato un account di servizio associato a un progetto eliminato. Scopri come visualizzare tutti gli account di servizio associati a un progetto.
Messaggio di errore L'account di servizio deve disporre delle autorizzazioni di editor nel progetto. Vai alla console Google Cloud Platform del progetto e concedi l'account di servizio che concede al tuo progetto l'autorizzazione di editor/proprietario delle chiamate seguendo queste istruzioni.
Messaggio di errore Le API di gestione degli stream devono essere chiamate solo da un account di servizio. Scopri di più su come chiamare le API di Google con un account di servizio.
Messaggio di errore L'endpoint di pubblicazione non appartiene a nessuno dei domini del progetto. Ogni progetto ha un set di domini autorizzati. Se l'endpoint di distribuzione (ad es. l'endpoint in cui prevedi che gli eventi RISC vengano pubblicati) non è ospitato su uno di questi, è necessario aggiungere il dominio dell'endpoint a tale set.
Messaggio di errore Per utilizzare questa API, il 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 sia utile per te. Scopri di più sull'utilizzo di OAuth da parte di Google per le nostre API.
Messaggio di errore

Stato non supportato.

Stato non valido.

Al momento supportiamo solo gli stati di streaming "enabled" e "disabled".
Messaggio di errore 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 di stream.
4XX/5XX Impossibile aggiornare lo stato. Per ulteriori informazioni, consulta il messaggio di errore dettagliato.

Ambiti token di accesso

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 Riferimento al codice di errore. Pubblica eventuali domande su Stack Overflow con il tag #SecEvents.